@antonytm/mcp-sitecore-server 0.20.4 → 0.21.0

package/dist/bundle.js

@@ -2,14 +2,16 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import fs from 'node:fs';
+import require$$0$1 from 'fs';
+import require$$1$1 from 'path';
+import require$$2$1 from 'os';
+import require$$3$1 from 'crypto';
 import process$1 from 'node:process';
-import 'fs';
-import require$$0$1 from 'path';
 import 'http';
 import { randomUUID } from 'node:crypto';
-import require$$2$1 from 'statuses';
+import require$$2$2 from 'statuses';
 import require$$0$2 from 'buffer';
-import require$$1$1 from 'string_decoder';
+import require$$1$2 from 'string_decoder';
 import contentType from 'content-type';
 import { URL as URL$1 } from 'url';
 import express from 'express';
@@ -3980,6 +3982,491 @@ ZodPromise.create;
 const optionalType = ZodOptional.create;
 ZodNullable.create;
 
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var config$1 = {};
+
+var main = {exports: {}};
+
+var version$1 = "16.6.0";
+var require$$4$1 = {
+	version: version$1};
+
+var hasRequiredMain;
+
+function requireMain () {
+	if (hasRequiredMain) return main.exports;
+	hasRequiredMain = 1;
+	const fs = require$$0$1;
+	const path = require$$1$1;
+	const os = require$$2$1;
+	const crypto = require$$3$1;
+	const packageJson = require$$4$1;
+
+	const version = packageJson.version;
+
+	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+
+	// Parse src into an Object
+	function parse (src) {
+	  const obj = {};
+
+	  // Convert buffer to string
+	  let lines = src.toString();
+
+	  // Convert line breaks to same format
+	  lines = lines.replace(/\r\n?/mg, '\n');
+
+	  let match;
+	  while ((match = LINE.exec(lines)) != null) {
+	    const key = match[1];
+
+	    // Default undefined or null to empty string
+	    let value = (match[2] || '');
+
+	    // Remove whitespace
+	    value = value.trim();
+
+	    // Check if double quoted
+	    const maybeQuote = value[0];
+
+	    // Remove surrounding quotes
+	    value = value.replace(/^(['"`])([\s\S]*)\1$/mg, '$2');
+
+	    // Expand newlines if double quoted
+	    if (maybeQuote === '"') {
+	      value = value.replace(/\\n/g, '\n');
+	      value = value.replace(/\\r/g, '\r');
+	    }
+
+	    // Add to object
+	    obj[key] = value;
+	  }
+
+	  return obj
+	}
+
+	function _parseVault (options) {
+	  const vaultPath = _vaultPath(options);
+
+	  // Parse .env.vault
+	  options.path = vaultPath;
+	  const result = DotenvModule.configDotenv(options);
+	  if (!result.parsed) {
+	    const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+	    err.code = 'MISSING_DATA';
+	    throw err
+	  }
+
+	  // handle scenario for comma separated keys - for use with key rotation
+	  // example: DOTENV_KEY="dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=prod,dotenv://:key_7890@dotenvx.com/vault/.env.vault?environment=prod"
+	  const keys = _dotenvKey(options).split(',');
+	  const length = keys.length;
+
+	  let decrypted;
+	  for (let i = 0; i < length; i++) {
+	    try {
+	      // Get full key
+	      const key = keys[i].trim();
+
+	      // Get instructions for decrypt
+	      const attrs = _instructions(result, key);
+
+	      // Decrypt
+	      decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+
+	      break
+	    } catch (error) {
+	      // last key
+	      if (i + 1 >= length) {
+	        throw error
+	      }
+	      // try next key
+	    }
+	  }
+
+	  // Parse decrypted .env string
+	  return DotenvModule.parse(decrypted)
+	}
+
+	function _warn (message) {
+	  console.log(`[dotenv@${version}][WARN] ${message}`);
+	}
+
+	function _debug (message) {
+	  console.log(`[dotenv@${version}][DEBUG] ${message}`);
+	}
+
+	function _log (message) {
+	  console.log(`[dotenv@${version}] ${message}`);
+	}
+
+	function _dotenvKey (options) {
+	  // prioritize developer directly setting options.DOTENV_KEY
+	  if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+	    return options.DOTENV_KEY
+	  }
+
+	  // secondary infra already contains a DOTENV_KEY environment variable
+	  if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+	    return process.env.DOTENV_KEY
+	  }
+
+	  // fallback to empty string
+	  return ''
+	}
+
+	function _instructions (result, dotenvKey) {
+	  // Parse DOTENV_KEY. Format is a URI
+	  let uri;
+	  try {
+	    uri = new URL(dotenvKey);
+	  } catch (error) {
+	    if (error.code === 'ERR_INVALID_URL') {
+	      const err = new Error('INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development');
+	      err.code = 'INVALID_DOTENV_KEY';
+	      throw err
+	    }
+
+	    throw error
+	  }
+
+	  // Get decrypt key
+	  const key = uri.password;
+	  if (!key) {
+	    const err = new Error('INVALID_DOTENV_KEY: Missing key part');
+	    err.code = 'INVALID_DOTENV_KEY';
+	    throw err
+	  }
+
+	  // Get environment
+	  const environment = uri.searchParams.get('environment');
+	  if (!environment) {
+	    const err = new Error('INVALID_DOTENV_KEY: Missing environment part');
+	    err.code = 'INVALID_DOTENV_KEY';
+	    throw err
+	  }
+
+	  // Get ciphertext payload
+	  const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+	  const ciphertext = result.parsed[environmentKey]; // DOTENV_VAULT_PRODUCTION
+	  if (!ciphertext) {
+	    const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+	    err.code = 'NOT_FOUND_DOTENV_ENVIRONMENT';
+	    throw err
+	  }
+
+	  return { ciphertext, key }
+	}
+
+	function _vaultPath (options) {
+	  let possibleVaultPath = null;
+
+	  if (options && options.path && options.path.length > 0) {
+	    if (Array.isArray(options.path)) {
+	      for (const filepath of options.path) {
+	        if (fs.existsSync(filepath)) {
+	          possibleVaultPath = filepath.endsWith('.vault') ? filepath : `${filepath}.vault`;
+	        }
+	      }
+	    } else {
+	      possibleVaultPath = options.path.endsWith('.vault') ? options.path : `${options.path}.vault`;
+	    }
+	  } else {
+	    possibleVaultPath = path.resolve(process.cwd(), '.env.vault');
+	  }
+
+	  if (fs.existsSync(possibleVaultPath)) {
+	    return possibleVaultPath
+	  }
+
+	  return null
+	}
+
+	function _resolveHome (envPath) {
+	  return envPath[0] === '~' ? path.join(os.homedir(), envPath.slice(1)) : envPath
+	}
+
+	function _configVault (options) {
+	  const debug = Boolean(options && options.debug);
+	  const quiet = Boolean(options && options.quiet);
+
+	  if (debug || !quiet) {
+	    _log('Loading env from encrypted .env.vault');
+	  }
+
+	  const parsed = DotenvModule._parseVault(options);
+
+	  let processEnv = process.env;
+	  if (options && options.processEnv != null) {
+	    processEnv = options.processEnv;
+	  }
+
+	  DotenvModule.populate(processEnv, parsed, options);
+
+	  return { parsed }
+	}
+
+	function configDotenv (options) {
+	  const dotenvPath = path.resolve(process.cwd(), '.env');
+	  let encoding = 'utf8';
+	  const debug = Boolean(options && options.debug);
+	  const quiet = Boolean(options && options.quiet);
+
+	  if (options && options.encoding) {
+	    encoding = options.encoding;
+	  } else {
+	    if (debug) {
+	      _debug('No encoding is specified. UTF-8 is used by default');
+	    }
+	  }
+
+	  let optionPaths = [dotenvPath]; // default, look for .env
+	  if (options && options.path) {
+	    if (!Array.isArray(options.path)) {
+	      optionPaths = [_resolveHome(options.path)];
+	    } else {
+	      optionPaths = []; // reset default
+	      for (const filepath of options.path) {
+	        optionPaths.push(_resolveHome(filepath));
+	      }
+	    }
+	  }
+
+	  // Build the parsed data in a temporary object (because we need to return it).  Once we have the final
+	  // parsed data, we will combine it with process.env (or options.processEnv if provided).
+	  let lastError;
+	  const parsedAll = {};
+	  for (const path of optionPaths) {
+	    try {
+	      // Specifying an encoding returns a string instead of a buffer
+	      const parsed = DotenvModule.parse(fs.readFileSync(path, { encoding }));
+
+	      DotenvModule.populate(parsedAll, parsed, options);
+	    } catch (e) {
+	      if (debug) {
+	        _debug(`Failed to load ${path} ${e.message}`);
+	      }
+	      lastError = e;
+	    }
+	  }
+
+	  let processEnv = process.env;
+	  if (options && options.processEnv != null) {
+	    processEnv = options.processEnv;
+	  }
+
+	  DotenvModule.populate(processEnv, parsedAll, options);
+
+	  if (debug || !quiet) {
+	    const keysCount = Object.keys(parsedAll).length;
+	    const shortPaths = [];
+	    for (const filePath of optionPaths) {
+	      try {
+	        const relative = path.relative(process.cwd(), filePath);
+	        shortPaths.push(relative);
+	      } catch {}
+	    }
+
+	    _log(`injecting env (${keysCount}) from ${shortPaths.join(',')}`);
+	  }
+
+	  if (lastError) {
+	    return { parsed: parsedAll, error: lastError }
+	  } else {
+	    return { parsed: parsedAll }
+	  }
+	}
+
+	// Populates process.env from .env file
+	function config (options) {
+	  // fallback to original dotenv if DOTENV_KEY is not set
+	  if (_dotenvKey(options).length === 0) {
+	    return DotenvModule.configDotenv(options)
+	  }
+
+	  const vaultPath = _vaultPath(options);
+
+	  // dotenvKey exists but .env.vault file does not exist
+	  if (!vaultPath) {
+	    _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+
+	    return DotenvModule.configDotenv(options)
+	  }
+
+	  return DotenvModule._configVault(options)
+	}
+
+	function decrypt (encrypted, keyStr) {
+	  const key = Buffer.from(keyStr.slice(-64), 'hex');
+	  let ciphertext = Buffer.from(encrypted, 'base64');
+
+	  const nonce = ciphertext.subarray(0, 12);
+	  const authTag = ciphertext.subarray(-16);
+	  ciphertext = ciphertext.subarray(12, -16);
+
+	  try {
+	    const aesgcm = crypto.createDecipheriv('aes-256-gcm', key, nonce);
+	    aesgcm.setAuthTag(authTag);
+	    return `${aesgcm.update(ciphertext)}${aesgcm.final()}`
+	  } catch (error) {
+	    const isRange = error instanceof RangeError;
+	    const invalidKeyLength = error.message === 'Invalid key length';
+	    const decryptionFailed = error.message === 'Unsupported state or unable to authenticate data';
+
+	    if (isRange || invalidKeyLength) {
+	      const err = new Error('INVALID_DOTENV_KEY: It must be 64 characters long (or more)');
+	      err.code = 'INVALID_DOTENV_KEY';
+	      throw err
+	    } else if (decryptionFailed) {
+	      const err = new Error('DECRYPTION_FAILED: Please check your DOTENV_KEY');
+	      err.code = 'DECRYPTION_FAILED';
+	      throw err
+	    } else {
+	      throw error
+	    }
+	  }
+	}
+
+	// Populate process.env with parsed values
+	function populate (processEnv, parsed, options = {}) {
+	  const debug = Boolean(options && options.debug);
+	  const override = Boolean(options && options.override);
+
+	  if (typeof parsed !== 'object') {
+	    const err = new Error('OBJECT_REQUIRED: Please check the processEnv argument being passed to populate');
+	    err.code = 'OBJECT_REQUIRED';
+	    throw err
+	  }
+
+	  // Set process.env
+	  for (const key of Object.keys(parsed)) {
+	    if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+	      if (override === true) {
+	        processEnv[key] = parsed[key];
+	      }
+
+	      if (debug) {
+	        if (override === true) {
+	          _debug(`"${key}" is already defined and WAS overwritten`);
+	        } else {
+	          _debug(`"${key}" is already defined and was NOT overwritten`);
+	        }
+	      }
+	    } else {
+	      processEnv[key] = parsed[key];
+	    }
+	  }
+	}
+
+	const DotenvModule = {
+	  configDotenv,
+	  _configVault,
+	  _parseVault,
+	  config,
+	  decrypt,
+	  parse,
+	  populate
+	};
+
+	main.exports.configDotenv = DotenvModule.configDotenv;
+	main.exports._configVault = DotenvModule._configVault;
+	main.exports._parseVault = DotenvModule._parseVault;
+	main.exports.config = DotenvModule.config;
+	main.exports.decrypt = DotenvModule.decrypt;
+	main.exports.parse = DotenvModule.parse;
+	main.exports.populate = DotenvModule.populate;
+
+	main.exports = DotenvModule;
+	return main.exports;
+}
+
+var envOptions;
+var hasRequiredEnvOptions;
+
+function requireEnvOptions () {
+	if (hasRequiredEnvOptions) return envOptions;
+	hasRequiredEnvOptions = 1;
+	// ../config.js accepts options via environment variables
+	const options = {};
+
+	if (process.env.DOTENV_CONFIG_ENCODING != null) {
+	  options.encoding = process.env.DOTENV_CONFIG_ENCODING;
+	}
+
+	if (process.env.DOTENV_CONFIG_PATH != null) {
+	  options.path = process.env.DOTENV_CONFIG_PATH;
+	}
+
+	if (process.env.DOTENV_CONFIG_QUIET != null) {
+	  options.quiet = process.env.DOTENV_CONFIG_QUIET;
+	}
+
+	if (process.env.DOTENV_CONFIG_DEBUG != null) {
+	  options.debug = process.env.DOTENV_CONFIG_DEBUG;
+	}
+
+	if (process.env.DOTENV_CONFIG_OVERRIDE != null) {
+	  options.override = process.env.DOTENV_CONFIG_OVERRIDE;
+	}
+
+	if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) {
+	  options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY;
+	}
+
+	envOptions = options;
+	return envOptions;
+}
+
+var cliOptions;
+var hasRequiredCliOptions;
+
+function requireCliOptions () {
+	if (hasRequiredCliOptions) return cliOptions;
+	hasRequiredCliOptions = 1;
+	const re = /^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/;
+
+	cliOptions = function optionMatcher (args) {
+	  const options = args.reduce(function (acc, cur) {
+	    const matches = cur.match(re);
+	    if (matches) {
+	      acc[matches[1]] = matches[2];
+	    }
+	    return acc
+	  }, {});
+
+	  if (!('quiet' in options)) {
+	    options.quiet = 'true';
+	  }
+
+	  return options
+	};
+	return cliOptions;
+}
+
+var hasRequiredConfig;
+
+function requireConfig () {
+	if (hasRequiredConfig) return config$1;
+	hasRequiredConfig = 1;
+	(function () {
+	  requireMain().config(
+	    Object.assign(
+	      {},
+	      requireEnvOptions(),
+	      requireCliOptions()(process.argv)
+	    )
+	  );
+	})();
+	return config$1;
+}
+
+requireConfig();
+
 objectType({
     name: stringType().default("mcp-sitecore-server"),
     version: stringType().optional(),
@@ -5802,12 +6289,6 @@ function mergeCapabilities(base, additional) {
     }, { ...base });
 }
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
 var uri_all$1 = {exports: {}};
 
 /** @license URI.js v4.4.1 (c) 2011 Gary Court. License: http://github.com/garycourt/uri-js */
@@ -31969,12 +32450,73 @@ const parseXMLString = function (xmlString) {
     return parser.parse(xmlString);
 };
 
+class PowershellCommandBuilder {
+    buildCommandString(script, parameters = {}) {
+        return `${script}${this.buildParametersString(parameters)}`;
+    }
+    buildParametersString(parameters = {}) {
+        let parametersString = '';
+        if (parameters) {
+            for (const parameter in parameters) {
+                if (parameters[parameter] === undefined || parameters[parameter] === null) {
+                    continue;
+                }
+                if (parameters[parameter] === "") {
+                    parametersString += ` -${parameter}`;
+                }
+                else if (Array.isArray(parameters[parameter])) {
+                    parametersString += ` -${parameter} "${parameters[parameter].join('","')}"`;
+                }
+                else if (this.isRecord(parameters[parameter])) {
+                    // Check whether the record has any keys
+                    if (Object.getOwnPropertyNames(parameters[parameter]).length > 0) {
+                        parametersString += ` -${parameter} ${this.buildPowershellHashtableString(parameters[parameter])}`;
+                    }
+                }
+                else {
+                    parametersString += ` -${parameter} "${parameters[parameter]}"`;
+                }
+            }
+        }
+        return parametersString;
+    }
+    buildPowershellHashtableString(parameters) {
+        let result = "@{ ";
+        let first = true;
+        for (const parameter in parameters) {
+            if (!first) {
+                result += "; ";
+            }
+            result += `"${parameter}" = "${parameters[parameter]}"`;
+            first = false;
+        }
+        result += " }";
+        return result;
+    }
+    isRecord(value) {
+        if (!value) {
+            return false;
+        }
+        if (typeof value !== "object") {
+            return false;
+        }
+        if (Array.isArray(value)) {
+            return false;
+        }
+        if (Object.getOwnPropertySymbols(value).length > 0) {
+            return false;
+        }
+        return Object.getOwnPropertyNames(value).every(prop => typeof value[prop] === "string");
+    }
+}
+
 class PowershellClient {
     serverUrl;
     username;
     password;
     domain;
     bearertoken = null;
+    commandBuilder = new PowershellCommandBuilder();
     constructor(serverUrl, username, password, domain = 'sitecore') {
         this.serverUrl = serverUrl;
         this.username = username;
@@ -31991,20 +32533,7 @@ class PowershellClient {
             'Authorization': this.bearertoken || '',
             'Content-Type': 'application/json',
         };
-        let scriptWithParameters = script;
-        if (parameters) {
-            for (const parameter in parameters) {
-                if (parameters[parameter] === "") {
-                    scriptWithParameters += ` -${parameter}`;
-                }
-                else if (Array.isArray(parameters[parameter])) {
-                    scriptWithParameters += ` -${parameter} "${parameters[parameter].join('","')}"`;
-                }
-                else {
-                    scriptWithParameters += ` -${parameter} "${parameters[parameter]}"`;
-                }
-            }
-        }
+        const scriptWithParameters = this.commandBuilder.buildCommandString(script, parameters);
         const body = `${scriptWithParameters}\r\n <#${uuid}#>\r\n`;
         const response = await fetch(url, {
             method: 'POST',
@@ -33113,6 +33642,18 @@ function prepareArgsString(parameters) {
     }
     return scriptWithParameters;
 }
+function getSwitchParameterValue(value) {
+    if (value === true) {
+        return "";
+    }
+    return undefined;
+}
+function getNumberParameterValue(value) {
+    if (value || value === 0) {
+        return value;
+    }
+    return undefined;
+}
 
 function setItemAclByIdPowerShellTool(server, config) {
     server.tool("security-set-item-acl-by-id", "Sets an access control entry to a Sitecore item by its ID.", {
@@ -33565,12 +34106,8 @@ function getLayoutByIdPowershellTool(server, config) {
         const command = `Get-Layout`;
         const options = {};
         options["Id"] = params.id;
-        if (params.finalLayout === true) {
-            options["FinalLayout"] = "";
-        }
-        if (params.language) {
-            options["Language"] = params.language;
-        }
+        options["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        options["Language"] = params.language;
         return safeMcpResponse(runGenericPowershellCommand(config, command, options));
     });
 }
@@ -33588,12 +34125,8 @@ function getLayoutByPathPowershellTool(server, config) {
         const command = `Get-Layout`;
         const options = {};
         options["Path"] = params.path;
-        if (params.finalLayout === true) {
-            options["FinalLayout"] = "";
-        }
-        if (params.language) {
-            options["Language"] = params.language;
-        }
+        options["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        options["Language"] = params.language;
         return safeMcpResponse(runGenericPowershellCommand(config, command, options));
     });
 }
@@ -33646,12 +34179,8 @@ function resetLayoutByIdPowershellTool(server, config) {
         const command = `Reset-Layout`;
         const options = {};
         options["Id"] = params.id;
-        if (params.finalLayout === true) {
-            options["FinalLayout"] = "";
-        }
-        if (params.language) {
-            options["Language"] = params.language;
-        }
+        options["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        options["Language"] = params.language;
         return safeMcpResponse(runGenericPowershellCommand(config, command, options));
     });
 }
@@ -33665,12 +34194,8 @@ function resetLayoutByPathPowershellTool(server, config) {
         const command = `Reset-Layout`;
         const options = {};
         options["Path"] = params.path;
-        if (params.finalLayout === true) {
-            options["FinalLayout"] = "";
-        }
-        if (params.language) {
-            options["Language"] = params.language;
-        }
+        options["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        options["Language"] = params.language;
         return safeMcpResponse(runGenericPowershellCommand(config, command, options));
     });
 }
@@ -33684,12 +34209,8 @@ function mergeLayoutByIdPowershellTool(server, config) {
         const command = `Merge-Layout`;
         const options = {};
         options["Id"] = params.id;
-        if (params.database) {
-            options["Database"] = params.database;
-        }
-        if (params.language) {
-            options["Language"] = params.language;
-        }
+        options["Database"] = params.database;
+        options["Language"] = params.language;
         return safeMcpResponse(runGenericPowershellCommand(config, command, options));
     });
 }
@@ -33702,9 +34223,7 @@ function mergeLayoutByPathPowershellTool(server, config) {
         const command = `Merge-Layout`;
         const options = {};
         options["Path"] = params.path;
-        if (params.language) {
-            options["Language"] = params.language;
-        }
+        options["Language"] = params.language;
         return safeMcpResponse(runGenericPowershellCommand(config, command, options));
     });
 }
@@ -33727,6 +34246,324 @@ function getDefaultLayoutDevicePowershellTool(server, config) {
     });
 }
 
+function getRenderingByIdPowershellTool(server, config) {
+    server.tool("presentation-get-rendering-by-id", "Gets rendering definition by item id.", {
+        itemId: stringType().describe("The id of the item to retrieve rendering for."),
+        database: stringType().describe("The context database.").optional(),
+        dataSource: stringType().describe("The rendering data source filter.").optional(),
+        placeholder: stringType().describe("The rendering datasource filter.").optional(),
+        language: stringType().describe("The item language filter.").optional(),
+        finalLayout: booleanType()
+            .describe("Specifies layout holding the rendering definition. If 'true', the final layout is used, otherwise - shared layout.")
+            .optional(),
+        uniqueId: stringType().describe("The rendering definition unique id.").optional(),
+    }, async (params) => {
+        const command = `Get-Rendering`;
+        const options = {};
+        options["Id"] = params.itemId;
+        options["Database"] = params.database;
+        options["DataSource"] = params.dataSource;
+        options["Placeholder"] = params.placeholder;
+        options["Language"] = params.language;
+        options["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        options["UniqueId"] = params.uniqueId;
+        return safeMcpResponse(runGenericPowershellCommand(config, command, options));
+    });
+}
+
+function getRenderingByPathPowershellTool(server, config) {
+    server.tool("presentation-get-rendering-by-path", "Gets rendering definition by item path.", {
+        path: stringType().describe("The id of the item to retrieve rendering for."),
+        dataSource: stringType().describe("The rendering data source filter.").optional(),
+        placeholder: stringType().describe("The rendering datasource filter.").optional(),
+        language: stringType().describe("The item language.").optional(),
+        finalLayout: booleanType()
+            .describe("Specifies layout holding the rendering definition. If 'true', the final layout is used, otherwise - shared layout.")
+            .optional(),
+        uniqueId: stringType().describe("The rendering definition unique id.").optional(),
+    }, async (params) => {
+        const command = `Get-Rendering`;
+        const options = {};
+        options["Path"] = params.path;
+        options["DataSource"] = params.dataSource;
+        options["Placeholder"] = params.placeholder;
+        options["Language"] = params.language;
+        options["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        options["UniqueId"] = params.uniqueId;
+        return safeMcpResponse(runGenericPowershellCommand(config, command, options));
+    });
+}
+
+function removeRenderingByPathPowershellTool(server, config) {
+    server.tool("presentation-remove-rendering-by-path", "Removes renderings from an item by owners item path.", {
+        path: stringType().describe("The path of the item to remove rendering from."),
+        uniqueId: stringType().describe("The rendering definition unique id."),
+        dataSource: stringType().describe("The rendering data source filter.").optional(),
+        placeholder: stringType().describe("The rendering placeholder filter.").optional(),
+        language: stringType().describe("The item language filter.").optional(),
+        finalLayout: booleanType()
+            .describe("Specifies layout holding the rendering definition. If 'true', the final layout is used, otherwise - shared layout.")
+            .optional(),
+    }, async (params) => {
+        const command = `Remove-Rendering`;
+        const options = {};
+        options["Path"] = params.path;
+        options["UniqueId"] = params.uniqueId;
+        options["DataSource"] = params.dataSource;
+        options["Placeholder"] = params.placeholder;
+        options["Language"] = params.language;
+        options["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        return safeMcpResponse(runGenericPowershellCommand(config, command, options));
+    });
+}
+
+function removeRenderingByIdPowershellTool(server, config) {
+    server.tool("presentation-remove-rendering-by-id", "Removes renderings from an item by owners item ID.", {
+        itemId: stringType().describe("The ID of the item to remove rendering from."),
+        uniqueId: stringType().describe("The rendering definition unique id."),
+        database: stringType().describe("The database of the item to remove rendering from.").optional(),
+        dataSource: stringType().describe("The rendering data source filter.").optional(),
+        placeholder: stringType().describe("The rendering placeholder filter.").optional(),
+        language: stringType().describe("The item language filter.").optional(),
+        finalLayout: booleanType()
+            .describe("Specifies layout holding the rendering definition. If 'true', the final layout is used, otherwise - shared layout.")
+            .optional(),
+    }, async (params) => {
+        const command = `Remove-Rendering`;
+        const options = {};
+        options["Id"] = params.itemId;
+        options["UniqueId"] = params.uniqueId;
+        options["Database"] = params.database;
+        options["DataSource"] = params.dataSource;
+        options["Placeholder"] = params.placeholder;
+        options["Language"] = params.language;
+        options["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        return safeMcpResponse(runGenericPowershellCommand(config, command, options));
+    });
+}
+
+function addRenderingByPathPowershellTool(server, config) {
+    server.tool("presentation-add-rendering-by-path", "Adds a rendering to presentation of an item specified by path.", {
+        itemPath: stringType().describe("The path of the item to add the rendering to."),
+        renderingPath: stringType().describe("The path of the rendering to add."),
+        placeHolder: stringType().describe("The placeholder to add the rendering to.").optional(),
+        dataSource: stringType().describe("The rendering data source.").optional(),
+        finalLayout: booleanType()
+            .describe("Specifies layout to add the rendering to. If 'true', the final layout is used, otherwise - shared layout.")
+            .optional(),
+        language: stringType().describe("The language version of the item to add the rendering to.").optional(),
+        index: numberType().describe("The index at which the Rendering should be inserted.").optional(),
+    }, async (params) => {
+        const commandBuilder = new PowershellCommandBuilder();
+        const addRenderingParameters = {};
+        addRenderingParameters["Path"] = params.itemPath;
+        addRenderingParameters["Placeholder"] = params.placeHolder;
+        addRenderingParameters["DataSource"] = params.dataSource;
+        addRenderingParameters["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        addRenderingParameters["Language"] = params.language;
+        addRenderingParameters["Index"] = getNumberParameterValue(params.index);
+        const command = `
+                $rendering = New-Rendering -Path "${params.renderingPath}";
+                Add-Rendering -Instance $rendering ${commandBuilder.buildParametersString(addRenderingParameters)};
+            `;
+        return safeMcpResponse(runGenericPowershellCommand(config, command, {}));
+    });
+}
+
+function addRenderingByIdPowershellTool(server, config) {
+    server.tool("presentation-add-rendering-by-id", "Adds a rendering to presentation of an item specified by item ID.", {
+        itemId: stringType().describe("The ID of the item to add the rendering to."),
+        renderingId: stringType().describe("The ID of the rendering to add."),
+        database: stringType().describe("The context database.").default("master").optional(),
+        placeHolder: stringType().describe("The placeholder to add the rendering to.").optional(),
+        dataSource: stringType().describe("The rendering data source.").optional(),
+        finalLayout: booleanType()
+            .describe("Specifies layout to add the rendering to. If 'true', the final layout is used, otherwise - shared layout.")
+            .optional(),
+        language: stringType().describe("The language version of the item to add the rendering to.").optional(),
+        index: numberType().describe("The index at which the Rendering should be inserted.").optional(),
+    }, async (params) => {
+        const commandBuilder = new PowershellCommandBuilder();
+        const addRenderingParameters = {};
+        addRenderingParameters["Id"] = params.itemId;
+        addRenderingParameters["Placeholder"] = params.placeHolder;
+        addRenderingParameters["DataSource"] = params.dataSource;
+        addRenderingParameters["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        addRenderingParameters["Database"] = params.database;
+        addRenderingParameters["Language"] = params.language;
+        addRenderingParameters["Index"] = getNumberParameterValue(params.index);
+        const command = `
+                $rendering = New-Rendering -Id ${params.renderingId} -Database ${params.database};
+                Add-Rendering -Instance $rendering ${commandBuilder.buildParametersString(addRenderingParameters)};
+            `;
+        return safeMcpResponse(runGenericPowershellCommand(config, command, {}));
+    });
+}
+
+function setRenderingByPathPowershellTool(server, config) {
+    server.tool("presentation-set-rendering-by-path", "Updates rendering specified by item path with new values.", {
+        itemPath: stringType().describe("The path of the item holding the rendering."),
+        uniqueId: stringType().describe("The unique ID of the rendering."),
+        placeholder: stringType().describe("New rendering placeholder value if specified.").optional(),
+        dataSource: stringType().describe("New rendering data source if specified.").optional(),
+        finalLayout: booleanType()
+            .describe("Specifies the layout to update the rendering. If 'true', the final layout is used, otherwise - shared layout.")
+            .optional(),
+        language: stringType().describe("The language version of the item holding the rendering.").optional(),
+        index: numberType().describe("New index of the rendering in the layout.").optional(),
+        parameter: recordType(stringType(), stringType()).describe("New rendering parameters if specified.").optional(),
+    }, async (params) => {
+        const commandBuilder = new PowershellCommandBuilder();
+        const getRenderingParameters = {};
+        getRenderingParameters["Path"] = params.itemPath;
+        getRenderingParameters["UniqueId"] = params.uniqueId;
+        const setRenderingParameters = {};
+        setRenderingParameters["Path"] = params.itemPath;
+        setRenderingParameters["Placeholder"] = params.placeholder;
+        setRenderingParameters["DataSource"] = params.dataSource;
+        setRenderingParameters["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        setRenderingParameters["Language"] = params.language;
+        setRenderingParameters["Index"] = getNumberParameterValue(params.index);
+        setRenderingParameters["Parameter"] = params.parameter;
+        const command = `
+                $rendering = Get-Rendering ${commandBuilder.buildParametersString(getRenderingParameters)};
+                Set-Rendering -Instance $rendering ${commandBuilder.buildParametersString(setRenderingParameters)};
+            `;
+        return safeMcpResponse(runGenericPowershellCommand(config, command, {}));
+    });
+}
+
+function setRenderingByIdPowershellTool(server, config) {
+    server.tool("presentation-set-rendering-by-id", "Updates rendering specified by item ID with new values.", {
+        itemId: stringType().describe("The ID of the item holding the rendering."),
+        uniqueId: stringType().describe("The unique ID of the rendering."),
+        database: stringType().describe("The context database.").default("master").optional(),
+        placeholder: stringType().describe("New rendering placeholder value if specified.").optional(),
+        dataSource: stringType().describe("New rendering data source if specified.").optional(),
+        finalLayout: booleanType()
+            .describe("Specifies the layout to update the rendering. If 'true', the final layout is used, otherwise - shared layout.")
+            .optional(),
+        language: stringType().describe("The language version of the item holding the rendering.").optional(),
+        index: numberType().describe("New index of the rendering in the layout.").optional(),
+        parameter: recordType(stringType(), stringType()).describe("New rendering parameters if specified.").optional(),
+    }, async (params) => {
+        const commandBuilder = new PowershellCommandBuilder();
+        const getRenderingParameters = {};
+        getRenderingParameters["Id"] = params.itemId;
+        getRenderingParameters["UniqueId"] = params.uniqueId;
+        getRenderingParameters["Database"] = params.database;
+        const setRenderingParameters = {};
+        setRenderingParameters["Id"] = params.itemId;
+        setRenderingParameters["Database"] = params.database;
+        setRenderingParameters["Placeholder"] = params.placeholder;
+        setRenderingParameters["DataSource"] = params.dataSource;
+        setRenderingParameters["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        setRenderingParameters["Language"] = params.language;
+        setRenderingParameters["Index"] = getNumberParameterValue(params.index);
+        setRenderingParameters["Parameter"] = params.parameter;
+        const command = `
+                $rendering = Get-Rendering ${commandBuilder.buildParametersString(getRenderingParameters)};
+                Set-Rendering -Instance $rendering ${commandBuilder.buildParametersString(setRenderingParameters)};
+            `;
+        return safeMcpResponse(runGenericPowershellCommand(config, command, {}));
+    });
+}
+
+function switchRenderingByIdPowershellTool(server, config) {
+    server.tool("presentation-switch-rendering-by-id", "Switches an existing rendering specified by item ID with an alternate one for the item specified by item ID.", {
+        itemId: stringType().describe("The ID of the item holding the renderings."),
+        oldRenderingId: stringType().describe("The ID of the rendering to switch."),
+        newRenderingId: stringType().describe("The ID of the new rendering."),
+        database: stringType().describe("The context database.").default("master").optional(),
+        finalLayout: booleanType()
+            .describe("Specifies the layout to update the rendering. If 'true', the final layout is used, otherwise - shared layout.")
+            .optional(),
+        language: stringType().describe("The language version of the item holding the renderings.").optional(),
+    }, async (params) => {
+        const commandBuilder = new PowershellCommandBuilder();
+        const getRenderingParameters = {};
+        getRenderingParameters["Id"] = params.itemId;
+        getRenderingParameters["Database"] = params.database;
+        getRenderingParameters["Language"] = params.language;
+        getRenderingParameters["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        const newRenderingParameters = {};
+        newRenderingParameters["Id"] = params.newRenderingId;
+        newRenderingParameters["Database"] = params.database;
+        const switchRenderingParameters = {};
+        switchRenderingParameters["Id"] = params.itemId;
+        switchRenderingParameters["Database"] = params.database;
+        switchRenderingParameters["Language"] = params.language;
+        switchRenderingParameters["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        const command = `
+                $sourceRenderings = Get-Rendering ${commandBuilder.buildParametersString(getRenderingParameters)} | Where-Object { $_.ItemID -ceq "${params.oldRenderingId}" };
+                $targetRendering = New-Rendering ${commandBuilder.buildParametersString(newRenderingParameters)}
+                foreach($sourceRendering in $sourceRenderings) {
+                    Switch-Rendering -Instance $sourceRendering -NewRendering $targetRendering ${commandBuilder.buildParametersString(switchRenderingParameters)}
+                }                
+            `;
+        return safeMcpResponse(runGenericPowershellCommand(config, command, {}));
+    });
+}
+
+function switchRenderingByPathPowershellTool(server, config) {
+    server.tool("presentation-switch-rendering-by-path", "Switches an existing rendering specified by path with an alternate one for the item specified by path.", {
+        itemPath: stringType().describe("The path of the item holding the renderings."),
+        oldRenderingPath: stringType().describe("The path of the rendering to switch."),
+        newRenderingPath: stringType().describe("The path of the new rendering."),
+        finalLayout: booleanType()
+            .describe("Specifies the layout to update the rendering. If 'true', the final layout is used, otherwise - shared layout.")
+            .optional(),
+        language: stringType().describe("The language version of the item holding the renderings.").optional(),
+    }, async (params) => {
+        const commandBuilder = new PowershellCommandBuilder();
+        const getRenderingParameters = {};
+        getRenderingParameters["Path"] = params.itemPath;
+        getRenderingParameters["Language"] = params.language;
+        getRenderingParameters["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        const newRenderingParameters = {};
+        newRenderingParameters["Path"] = params.newRenderingPath;
+        const switchRenderingParameters = {};
+        switchRenderingParameters["Path"] = params.itemPath;
+        switchRenderingParameters["Language"] = params.language;
+        switchRenderingParameters["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        const command = `
+                $oldRendering = Get-Item -Path "${params.oldRenderingPath}"
+                $sourceRenderings = Get-Rendering ${commandBuilder.buildParametersString(getRenderingParameters)} | Where-Object { $_.ItemID -ceq $oldRendering.ID.ToString() };
+                $targetRendering = New-Rendering ${commandBuilder.buildParametersString(newRenderingParameters)}
+                foreach($sourceRendering in $sourceRenderings) {
+                    Switch-Rendering -Instance $sourceRendering  -NewRendering $targetRendering ${commandBuilder.buildParametersString(switchRenderingParameters)}
+                }  
+            `;
+        return safeMcpResponse(runGenericPowershellCommand(config, command, {}));
+    });
+}
+
+function switchRenderingByUniqueIdPowershellTool(server, config) {
+    server.tool("presentation-switch-rendering-by-unique-id", "Switches an existing rendering specified by unique ID with an alternate one for the item specified by item ID.", {
+        itemId: stringType().describe("The ID of the item holding the rendering."),
+        uniqueId: stringType().describe("The unique ID of the rendering to switch."),
+        newRenderingId: stringType().describe("The ID of the new rendering."),
+        database: stringType().describe("The context database.").default("master").optional(),
+        finalLayout: booleanType()
+            .describe("Specifies the layout to update the rendering. If 'true', the final layout is used, otherwise - shared layout.")
+            .optional(),
+        language: stringType().describe("The language version of the item holding the renderings.").optional(),
+    }, async (params) => {
+        const commandBuilder = new PowershellCommandBuilder();
+        const switchRenderingParameters = {};
+        switchRenderingParameters["Id"] = params.itemId;
+        switchRenderingParameters["UniqueId"] = params.uniqueId;
+        switchRenderingParameters["Database"] = params.database;
+        switchRenderingParameters["FinalLayout"] = getSwitchParameterValue(params.finalLayout);
+        switchRenderingParameters["Language"] = params.language;
+        const command = `
+                $targetRendering = New-Rendering -Id "${params.newRenderingId}" -Database "${params.database}"
+                Switch-Rendering -NewRendering $targetRendering ${commandBuilder.buildParametersString(switchRenderingParameters)}
+            `;
+        return safeMcpResponse(runGenericPowershellCommand(config, command, {}));
+    });
+}
+
 var LogLevel;
 (function (LogLevel) {
     LogLevel["DEBUG"] = "DEBUG";
@@ -33926,9 +34763,20 @@ async function registerAll(server, config) {
         mergeLayoutByPathPowershellTool,
         getLayoutDevicePowershellTool,
         getDefaultLayoutDevicePowershellTool,
-        //Composite Layout PowerShell Tools
+        getRenderingByIdPowershellTool,
+        getRenderingByPathPowershellTool,
+        removeRenderingByPathPowershellTool,
+        removeRenderingByIdPowershellTool,
+        //Composite Presentation PowerShell Tools
         setLayoutIdPowershellTool,
         setLayoutByPathPowershellTool,
+        addRenderingByPathPowershellTool,
+        addRenderingByIdPowershellTool,
+        setRenderingByPathPowershellTool,
+        setRenderingByIdPowershellTool,
+        switchRenderingByIdPowershellTool,
+        switchRenderingByPathPowershellTool,
+        switchRenderingByUniqueIdPowershellTool,
         //Logging
         getLogsPowerShellTool,
         //Provider
@@ -34180,7 +35028,7 @@ function requireDepd () {
 	 * Module dependencies.
 	 */
 
-	var relative = require$$0$1.relative;
+	var relative = require$$1$1.relative;
 
 	/**
 	 * Module exports.
@@ -34853,7 +35701,7 @@ function requireHttpErrors () {
 
 		var deprecate = requireDepd()('http-errors');
 		var setPrototypeOf = requireSetprototypeof();
-		var statuses = require$$2$1;
+		var statuses = require$$2$2;
 		var inherits = requireInherits();
 		var toIdentifier = requireToidentifier();
 
@@ -35332,7 +36180,7 @@ function requireInternal () {
 	//------------------------------------------------------------------------------
 
 	// We use node.js internal decoder. Its signature is the same as ours.
-	var StringDecoder = require$$1$1.StringDecoder;
+	var StringDecoder = require$$1$2.StringDecoder;
 
 	if (!StringDecoder.prototype.end) // Node v0.8 doesn't have this method.
 	    StringDecoder.prototype.end = function() {};