@boltic/cli 1.0.27-1 → 1.0.27

package/README.md

@@ -1,6 +1,6 @@
 # ⚡ Boltic CLI
 
-> **Professional CLI tool for creating, managing, and publishing Boltic Workflow integrations with enterprise-grade features and seamless developer experience.**
+> **Professional CLI for interacting with the Boltic platform — create, manage, and publish integrations, workflows, MCPs, and more with enterprise-grade features and a seamless developer experience.**
 
 [![NPM Version](https://img.shields.io/npm/v/@boltic/cli)](https://www.npmjs.com/package/@boltic/cli)
 [![GitHub Repo](https://img.shields.io/badge/GitHub-Repo-blue?logo=github)](https://github.com/bolticio/cli)
@@ -13,7 +13,7 @@
 
 ![Boltic CLI](https://img.shields.io/badge/Boltic-CLI-00D4AA?style=for-the-badge&logo=node.js&logoColor=white)
 
-**Streamline your integration development workflow with Boltic CLI**
+**Streamline your developer workflow on the Boltic platform**
 
 [Features](#-features) • [Installation](#-installation) • [Quick Start](#-quick-start) • [Documentation](#-documentation) • [Contributing](#-contributing)
 
@@ -28,6 +28,7 @@
 - [📦 Installation](#-installation)
 - [🔐 Authentication](#-authentication)
 - [🧩 Integration Management](#-integration-management)
+- [🧠 MCP](#-mcp-model-context-protocol)
 - [📚 Command Reference](#-command-reference)
 - [🛠️ Development Workflow](#️-development-workflow)
 - [🔧 Configuration](#-configuration)
@@ -42,12 +43,12 @@
 ## ✨ Features
 
 - 🔐 **Secure Authentication** - Enterprise-grade token management with secure storage
-- 🚀 **Rapid Integration Development** - Create integrations in minutes, not hours
+- 🚀 **Rapid Development** - Create workflows, integrations, and more in minutes, not hours
 - 📦 **Smart Project Management** - Automated folder structure and configuration
 - 🔄 **Real-time Synchronization** - Instant sync with Boltic Cloud platform
 - 🎯 **Type-safe Development** - Support for Workflow Activities and Triggers
 - 🎨 **Rich Interactive UI** - Beautiful command-line interface with progress indicators
-- 📊 **Comprehensive Validation** - Built-in validation for all integration components
+- 📊 **Comprehensive Validation** - Built-in validation for platform resources and components
 - 🔧 **Developer Experience** - Hot reload, debugging tools, and comprehensive error handling
 - 🌐 **Multi-platform Support** - Works seamlessly on Windows, macOS, and Linux
 - 📈 **Version Control Integration** - Git-friendly workflow with proper ignore patterns
@@ -62,7 +63,7 @@ Get up and running with Boltic CLI in under 2 minutes:
 # Install Boltic CLI globally
 npm install -g @boltic/cli
 
-# Authenticate with your Boltic account
+# Authenticate with your Boltic account (if required for commands)
 boltic login
 
 # Create your first integration
@@ -225,9 +226,7 @@ my-integration/
 │   ├── base.json
 │   └── webhook.json
 ├── Authentication.mdx
-├── documentation/
-│   ├── integration.mdx
-│   └── trigger.mdx
+├── Documentation.mdx
 └── spec.json
 ```
 
@@ -239,11 +238,9 @@ my-integration/
     - **`base.json`** - Base integration configuration and parameters
     - **`webhook.json`** - Webhook configuration (for trigger integrations)
 
-**Documentation files:**
-- `Authentication.mdx` - Authentication documentation in Markdown format (optional, created when catalogue is enabled)
-- `documentation/integration.mdx` - Activity documentation (required when activity_type is present; falls back to legacy `Documentation.mdx`)
-- `documentation/trigger.mdx` - Trigger documentation (required when trigger_type is "CloudTrigger")
-- `spec.json` - Integration specification and metadata
+- **`Authentication.mdx`** - Authentication documentation in Markdown format
+- **`Documentation.mdx`** - General integration documentation
+- **`spec.json`** - Integration specification and metadata
 
 ### Managing Existing Integrations
 
@@ -278,6 +275,26 @@ boltic integration submit
 
 ---
 
+## 🔌 MCP Management
+
+The CLI includes utilities to set up MCP connections for popular clients. This helps your AI tools connect to Boltic services via STDIO or Streamable HTTP.
+
+### Usage
+
+```bash
+# Basic: configure MCP for Claude Desktop (default client)
+boltic mcp setup https://mcp.boltic.io/sse
+
+# Specify client and a friendly name
+boltic mcp setup https://mcp.boltic.io/sse my-boltic --client claude
+
+# Supported clients (examples):
+# claude, cline, roocode, windsurf, cursor, vscode, vscode-insiders,
+# witsy, enconvo, boltai, amazon-bedrock, amazonq, librechat, gemini-cli
+```
+
+---
+
 ## 📚 Command Reference
 
 ### Core Commands
@@ -301,6 +318,13 @@ boltic integration submit
 | `boltic integration status` | Check integration status  | Interactive selection |
 | `boltic integration help`   | Show integration help     |                       |
 
+### MCP Commands
+
+| Command            | Description                                  | Options                           |
+| ------------------ | -------------------------------------------- | --------------------------------- |
+| `boltic mcp help`  | Show help for MCP sub-commands               |                                   |
+| `boltic mcp setup` | Configure an MCP server for a specific client| `--client <name>` `--name <alias>`|
+
 ### Help and Documentation
 
 ```bash
@@ -423,7 +447,7 @@ boltic --verbose login
 
 ```bash
 # Verify project structure
-ls -la  # Should show: schemas/, Authentication.mdx (optional), documentation/, spec.json
+ls -la  # Should show: schemas/, Authentication.mdx, Documentation.mdx, spec.json
 
 # Check file permissions
 ls -la schemas/

package/cli.js

@@ -4,6 +4,7 @@ import path from "path";
 import { fileURLToPath } from "url";
 import EnvironmentCommands from "./commands/env.js";
 import IntegrationCommands from "./commands/integration.js";
+import McpCommands from "./commands/mcp.js";
 import AuthCommands from "./commands/login.js";
 
 // Create a CLI module with functional approach
@@ -22,6 +23,10 @@ const createCLI = (consoleUrl, apiUrl, serviceName, env) => {
 			description: "Manage integrations (create, list)",
 			action: (args) => handleIntegration(args),
 		},
+		mcp: {
+			description: "Manage MCPs clients and servers",
+			action: (args) => handleMcp(args),
+		},
 		logout: {
 			description: "Logout and clear access token",
 			action: AuthCommands.handleLogout,
@@ -157,6 +162,10 @@ async function handleEnvironment(args) {
 	await EnvironmentCommands.execute(args);
 }
 
+async function handleMcp(args) {
+	await McpCommands.execute(args);
+}
+
 async function showVersion() {
 	let version = "1.0.0";
 	try {

package/commands/integration.js

@@ -114,16 +114,6 @@ async function readSchemaFiles(currentDir) {
 	// Read documentation files
 	const authDocPath = path.join(currentDir, "Authentication.mdx");
 	const generalDocPath = path.join(currentDir, "Documentation.mdx");
-	const docsIntegrationPath = path.join(
-		currentDir,
-		"documentation",
-		"integration.mdx"
-	);
-	const docsTriggerPath = path.join(
-		currentDir,
-		"documentation",
-		"trigger.mdx"
-	);
 
 	if (fs.existsSync(authDocPath)) {
 		schemas.authentication_documentation = fs.readFileSync(
@@ -132,22 +122,8 @@ async function readSchemaFiles(currentDir) {
 		);
 	}
 
-	// Build documentation object with backward compatibility
-	const documentation = {};
-	if (fs.existsSync(docsIntegrationPath)) {
-		documentation.integration = fs.readFileSync(
-			docsIntegrationPath,
-			"utf8"
-		);
-	} else if (fs.existsSync(generalDocPath)) {
-		// Fallback to legacy Documentation.mdx
-		documentation.integration = fs.readFileSync(generalDocPath, "utf8");
-	}
-	if (fs.existsSync(docsTriggerPath)) {
-		documentation.trigger = fs.readFileSync(docsTriggerPath, "utf8");
-	}
-	if (Object.keys(documentation).length > 0) {
-		schemas.documentation = documentation;
+	if (fs.existsSync(generalDocPath)) {
+		schemas.documentation = fs.readFileSync(generalDocPath, "utf8");
 	}
 
 	return schemas;
@@ -1115,25 +1091,7 @@ async function handleStatus() {
 
 		if (integration.documentation) {
 			console.log(chalk.cyan("\nDocumentation:"));
-			if (
-				typeof integration.documentation === "object" &&
-				integration.documentation !== null
-			) {
-				if (integration.documentation.integration) {
-					console.log(
-						chalk.dim("integration.mdx:\n") +
-							integration.documentation.integration
-					);
-				}
-				if (integration.documentation.trigger) {
-					console.log(
-						chalk.dim("\ntrigger.mdx:\n") +
-							integration.documentation.trigger
-					);
-				}
-			} else {
-				console.log(integration.documentation);
-			}
+			console.log(integration.documentation);
 		}
 	} catch (error) {
 		if (

package/commands/mcp.js

@@ -0,0 +1,374 @@
+import chalk from "chalk";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import yaml from "js-yaml";
+import { execFileSync } from "child_process";
+
+// Types removed for CommonJS conversion
+
+const commands = {
+	setup: {
+		description: "Setup command for various MCP Clients",
+		action: handleSetup,
+	},
+	help: {
+		description: "Show help for mcp commands",
+		action: showHelp,
+	},
+};
+
+// Execute the MCP command
+const execute = async (args) => {
+	const subCommand = args[0];
+
+	if (!subCommand) {
+		showHelp();
+		return;
+	}
+
+	if (!commands[subCommand]) {
+		console.log(chalk.red("Unknown or missing mcp sub-command.\n"));
+		showHelp();
+		return;
+	}
+
+	const commandObj = commands[subCommand];
+	await commandObj.action(args.slice(1));
+};
+
+function showHelp() {
+	console.log(chalk.cyan("\nMCP Commands:\n"));
+	Object.entries(commands).forEach(([cmd, details]) => {
+		console.log(chalk.bold(`${cmd}`) + ` - ${details.description}`);
+	});
+}
+
+// Handle setup subcommand: setup <url> [name] --client <client>
+async function handleSetup(args) {
+	// Parse positional args
+	const url = args[0];
+	let name = args[1] && !args[1].startsWith("--") ? args[1] : undefined;
+
+	// Parse flags: --client, --name
+	let client = "claude";
+	for (let i = 0; i < args.length; i++) {
+		const token = args[i];
+		if (
+			token === "--client" &&
+			args[i + 1] &&
+			!args[i + 1].startsWith("--")
+		) {
+			client = args[i + 1];
+			i++;
+		} else if (token.startsWith("--client=")) {
+			client = token.split("=")[1];
+		} else if (
+			token === "--name" &&
+			args[i + 1] &&
+			!args[i + 1].startsWith("--")
+		) {
+			name = args[i + 1];
+			i++;
+		} else if (token.startsWith("--name=")) {
+			name = token.split("=")[1];
+		}
+	}
+
+	if (!url) {
+		console.log(
+			chalk.red(
+				"❌ URL is required. Usage: boltic mcp setup <url> [name] --client <client>"
+			)
+		);
+		return;
+	}
+
+	const newKey =
+		name || url.split("/").slice(3).join("/").replace(/\//g, "-");
+
+	try {
+		console.log(chalk.cyan("📝 Configuration Details:"));
+		console.log(`   URL: ${chalk.green(url)}`);
+		console.log(`   Client: ${chalk.green(client)}`);
+		console.log(`   Name: ${chalk.green(newKey)}\n`);
+
+		const mcpUrl = url;
+		const command = `composio --sse "${mcpUrl}"`;
+
+		console.log(chalk.cyan("💾 Saving configurations..."));
+
+		saveMcpConfig(url, client, newKey, mcpUrl, command);
+
+		console.log(
+			chalk.cyan(
+				`\n🚀 All done! Please restart ${client} for changes to take effect\n`
+			)
+		);
+	} catch (error) {
+		console.log(chalk.red("\n❌ Error occurred while setting up MCP:"));
+		console.log(
+			chalk.red(
+				`   ${error && error.message ? error.message : String(error)}`
+			)
+		);
+		console.log(
+			chalk.yellow(
+				"\nPlease try again or contact support if the issue persists.\n"
+			)
+		);
+	}
+}
+
+function saveMcpConfig(url, clientType, name, mcpUrl, command) {
+	const config = {
+		command: "npx",
+		args: ["-y", "mcp-remote", mcpUrl],
+		env: {
+			npm_config_yes: "true",
+		},
+	};
+
+	const sseConfig = {
+		url: mcpUrl,
+	};
+
+	const homeDir = os.homedir();
+
+	const platformPaths = {
+		win32: {
+			baseDir:
+				process.env.APPDATA || path.join(homeDir, "AppData", "Roaming"),
+			vscodePath: path.join("Code", "User", "globalStorage"),
+		},
+		darwin: {
+			baseDir: path.join(homeDir, "Library", "Application Support"),
+			vscodePath: path.join("Code", "User", "globalStorage"),
+		},
+		linux: {
+			baseDir:
+				process.env.XDG_CONFIG_HOME || path.join(homeDir, ".config"),
+			vscodePath: path.join("Code/User/globalStorage"),
+		},
+	};
+
+	const platform = process.platform;
+
+	// Check if platform is supported
+	if (!platformPaths[platform]) {
+		console.log(chalk.red(`\n❌ Platform ${platform} is not supported.`));
+		process.exit(1);
+	}
+
+	const { baseDir } = platformPaths[platform];
+
+	const defaultClaudePath = path.join(
+		baseDir,
+		"Claude",
+		"claude_desktop_config.json"
+	);
+
+	// Define client paths using the platform-specific base directories
+	const clientPaths = {
+		claude: {
+			type: "file",
+			path: defaultClaudePath,
+		},
+		cline: {
+			type: "file",
+			path: path.join(
+				baseDir,
+				platformPaths[platform].vscodePath,
+				"saoudrizwan.claude-dev",
+				"settings",
+				"cline_mcp_settings.json"
+			),
+		},
+		roocode: {
+			type: "file",
+			path: path.join(
+				baseDir,
+				platformPaths[platform].vscodePath,
+				"rooveterinaryinc.roo-cline",
+				"settings",
+				"mcp_settings.json"
+			),
+		},
+		windsurf: {
+			type: "file",
+			path: path.join(homeDir, ".codeium", "windsurf", "mcp_config.json"),
+		},
+		witsy: {
+			type: "file",
+			path: path.join(baseDir, "Witsy", "settings.json"),
+		},
+		enconvo: {
+			type: "file",
+			path: path.join(homeDir, ".config", "enconvo", "mcp_config.json"),
+		},
+		cursor: {
+			type: "file",
+			path: path.join(homeDir, ".cursor", "mcp.json"),
+		},
+		vscode: {
+			type: "command",
+			command: process.platform === "win32" ? "code.cmd" : "code",
+		},
+		"vscode-insiders": {
+			type: "command",
+			command:
+				process.platform === "win32"
+					? "code-insiders.cmd"
+					: "code-insiders",
+		},
+		boltai: {
+			type: "file",
+			path: path.join(homeDir, ".boltai", "mcp.json"),
+		},
+		"amazon-bedrock": {
+			type: "file",
+			path: path.join(
+				homeDir,
+				"Amazon Bedrock Client",
+				"mcp_config.json"
+			),
+		},
+		amazonq: {
+			type: "file",
+			path: path.join(homeDir, ".aws", "amazonq", "mcp.json"),
+		},
+		librechat: {
+			type: "yaml",
+			path: path.join(homeDir, "LibreChat", "librechat.yaml"),
+		},
+		"gemini-cli": {
+			type: "file",
+			path: path.join(homeDir, ".gemini", "settings.json"),
+		},
+	};
+	if (!clientPaths[clientType]) {
+		console.log(chalk.red(`\n❌ Client ${clientType} is not supported.`));
+		process.exit(1);
+	}
+
+	const clientConfig = clientPaths[clientType];
+	const newKey =
+		name || url.split("/").slice(3).join("/").replace(/\//g, "-");
+
+	if (clientConfig.type === "command") {
+		handleCommandClient(clientConfig, newKey, config);
+	} else if (clientConfig.type === "yaml") {
+		handleYamlClient(clientConfig, newKey, config);
+	} else {
+		handleFileClient(clientConfig, newKey, config, mcpUrl);
+	}
+}
+
+function handleCommandClient(clientConfig, serverName, config) {
+	if (!clientConfig.command) {
+		throw new Error("Command not specified for command-type client");
+	}
+
+	const args = [];
+	args.push("--add-mcp", JSON.stringify({ ...config, name: serverName }));
+
+	try {
+		const output = execFileSync(clientConfig.command, args);
+		console.log(
+			chalk.green(
+				`✅ Configuration added via ${clientConfig.command}: ${output.toString()}`
+			)
+		);
+	} catch (error) {
+		if (error && error.code === "ENOENT") {
+			throw new Error(
+				`Command '${clientConfig.command}' not found. Make sure ${clientConfig.command} is installed and on your PATH`
+			);
+		}
+		throw error;
+	}
+}
+
+function handleYamlClient(clientConfig, serverName, config) {
+	if (!clientConfig.path) {
+		throw new Error("Path not specified for YAML client");
+	}
+
+	const configDir = path.dirname(clientConfig.path);
+	if (!fs.existsSync(configDir)) {
+		fs.mkdirSync(configDir, { recursive: true });
+	}
+
+	let existingYaml = {};
+
+	try {
+		if (fs.existsSync(clientConfig.path)) {
+			const originalContent = fs.readFileSync(clientConfig.path, "utf8");
+			existingYaml = yaml.load(originalContent) || {};
+		}
+	} catch (error) {
+		console.log(chalk.yellow("⚠️  Creating new YAML config file"));
+	}
+
+	// Initialize mcpServers if it doesn't exist
+	if (!existingYaml.mcpServers) {
+		existingYaml.mcpServers = {};
+	}
+
+	// Add the new server
+	existingYaml.mcpServers[serverName] = config;
+
+	// Write the updated YAML
+	const yamlContent = yaml.dump(existingYaml, {
+		indent: 2,
+		lineWidth: -1,
+		noRefs: true,
+	});
+
+	fs.writeFileSync(clientConfig.path, yamlContent);
+	console.log(chalk.green(`✅ Configuration saved to: ${clientConfig.path}`));
+}
+
+function handleFileClient(clientConfig, serverName, config, mcpUrl) {
+	if (!clientConfig.path) {
+		throw new Error("Path not specified for file client");
+	}
+
+	const configDir = path.dirname(clientConfig.path);
+	if (!fs.existsSync(configDir)) {
+		fs.mkdirSync(configDir, { recursive: true });
+	}
+
+	let existingConfig = { mcpServers: {} };
+
+	try {
+		if (fs.existsSync(clientConfig.path)) {
+			existingConfig = JSON.parse(
+				fs.readFileSync(clientConfig.path, "utf8")
+			);
+		}
+	} catch (error) {
+		console.log(chalk.yellow("⚠️  Creating new config file"));
+	}
+
+	// Ensure mcpServers exists
+	if (!existingConfig.mcpServers) existingConfig.mcpServers = {};
+
+	// Special handling for Cursor which uses SSE configuration
+	if (clientConfig.path?.includes(".cursor")) {
+		const sseConfig = {
+			url: mcpUrl,
+		};
+		existingConfig.mcpServers[serverName] = sseConfig;
+	} else {
+		existingConfig.mcpServers[serverName] = config;
+	}
+
+	fs.writeFileSync(
+		clientConfig.path,
+		JSON.stringify(existingConfig, null, 2)
+	);
+	console.log(chalk.green(`✅ Configuration saved to: ${clientConfig.path}`));
+}
+
+export default { execute };

package/helper/folder.js

@@ -47,9 +47,6 @@ export const createIntegrationFolderStructure = async (
 	const resourcesDir = path.join(schemasDir, "resources");
 	fs.mkdirSync(resourcesDir, { recursive: true });
 
-	const docsDir = path.join(integrationDir, "documentation");
-	fs.mkdirSync(docsDir, { recursive: true });
-
 	// Create template files
 	const files = {
 		"schemas/resources/resource1.json": JSON.stringify(resource1, null, 4),
@@ -72,13 +69,7 @@ export const createIntegrationFolderStructure = async (
 		...(create_catalogue && {
 			"Authentication.mdx": `# ${name} Authentication`,
 		}),
-		// Documentation files (new structure)
-		...(!isEmpty(activity_type) && {
-			"documentation/integration.mdx": `# ${name} Integration`,
-		}),
-		...(trigger_type === "CloudTrigger" && {
-			"documentation/trigger.mdx": `# ${name} Trigger`,
-		}),
+		"Documentation.mdx": `# ${name} Documentation`,
 	};
 
 	// Create all files
@@ -156,14 +147,7 @@ export const createExistingIntegrationsFolder = async (payload) => {
 	const resourcesDir = path.join(schemasDir, "resources");
 	fs.mkdirSync(resourcesDir, { recursive: true });
 
-	const docsDir = path.join(integrationDir, "documentation");
-	fs.mkdirSync(docsDir, { recursive: true });
-
 	const authentication_documentation = authentication?.documentation || "";
-	const isDocumentationObject =
-		documentation &&
-		typeof documentation === "object" &&
-		!Array.isArray(documentation);
 
 	// Define files and content
 	const files = {
@@ -184,17 +168,7 @@ export const createExistingIntegrationsFolder = async (payload) => {
 		...(authentication && {
 			"Authentication.mdx": authentication_documentation || "",
 		}),
-		...(!isEmpty(activity_type) && {
-			"documentation/integration.mdx": isDocumentationObject
-				? documentation?.integration || `# ${name} Integration`
-				: (typeof documentation === "string" && documentation) ||
-					`# ${name} Integration`,
-		}),
-		...(trigger_type === "CloudTrigger" && {
-			"documentation/trigger.mdx": isDocumentationObject
-				? documentation?.trigger || `# ${name} Trigger`
-				: `# ${name} Trigger`,
-		}),
+		"Documentation.mdx": documentation || "",
 	};
 
 	// Write resource files

package/helper/validation.js

@@ -2,7 +2,6 @@ import fs from "fs";
 import isEmpty from "lodash.isempty";
 import path from "path";
 import * as componentSchemas from "../templates/component-schemas.js";
-import { validateMarkdownFile } from "./markdown.js";
 
 const validateOptionObject = (options, fieldName, fileLabel, errors) => {
 	options.forEach((opt, index) => {
@@ -326,82 +325,9 @@ const validateComponentSchemas = (schemas, errors, filename = "") => {
 // INDIVIDUAL VALIDATORS
 // ─────────────────────────────────────────────────────────────────────────────
 
-const validateDocumentation = (currentDir, spec, errors) => {
-	const docsIntegrationPath = path.join(
-		currentDir,
-		"documentation",
-		"integration.mdx"
-	);
-	const docsTriggerPath = path.join(
-		currentDir,
-		"documentation",
-		"trigger.mdx"
-	);
-	const legacyDocPath = path.join(currentDir, "Documentation.mdx");
-
-	const requiresIntegrationDoc = spec && !isEmpty(spec.activity_type);
-	const requiresTriggerDoc = spec && spec.trigger_type === "CloudTrigger";
-
-	// Backward-compatibility: if nothing specific is required by spec,
-	// ensure at least legacy Documentation.mdx or new docs exist
-	const hasLegacy = fs.existsSync(legacyDocPath);
-	const hasNewIntegration = fs.existsSync(docsIntegrationPath);
-	const hasNewTrigger = fs.existsSync(docsTriggerPath);
-
-	if (!requiresIntegrationDoc && !requiresTriggerDoc) {
-		if (!hasLegacy && !hasNewIntegration && !hasNewTrigger) {
-			errors.add('"Documentation.mdx" not found in the root directory.');
-			return; // No further checks needed
-		}
-		// If files exist, validate whatever is present
-		if (hasLegacy) {
-			validateMarkdownFile(legacyDocPath, errors, "Documentation.mdx");
-		}
-		if (hasNewIntegration) {
-			validateMarkdownFile(
-				docsIntegrationPath,
-				errors,
-				"documentation/integration.mdx"
-			);
-		}
-		if (hasNewTrigger) {
-			validateMarkdownFile(
-				docsTriggerPath,
-				errors,
-				"documentation/trigger.mdx"
-			);
-		}
-		return;
-	}
-
-	if (requiresIntegrationDoc) {
-		const hasNew = validateMarkdownFile(
-			docsIntegrationPath,
-			errors,
-			"documentation/integration.mdx"
-		);
-		const hasLegacyValidated = validateMarkdownFile(
-			legacyDocPath,
-			errors,
-			"Documentation.mdx"
-		);
-		if (!hasNew && !hasLegacyValidated) {
-			// Maintain backward-compatible error message expected by tests
-			errors.add('"Documentation.mdx" not found in the root directory.');
-		}
-	}
-
-	if (requiresTriggerDoc) {
-		const hasTrigger = validateMarkdownFile(
-			docsTriggerPath,
-			errors,
-			"documentation/trigger.mdx"
-		);
-		if (!hasTrigger) {
-			errors.add(
-				'"documentation/trigger.mdx" not found when trigger_type is "CloudTrigger".'
-			);
-		}
+const validateDocumentation = (docPath, errors) => {
+	if (!fs.existsSync(docPath)) {
+		errors.add(`"Documentation.mdx" not found in the root directory.`);
 	}
 };
 
@@ -599,11 +525,13 @@ export const validateIntegrationSchemas = (currentDir) => {
 		spec: path.join(currentDir, "spec.json"),
 		webhook: path.join(currentDir, "schemas", "webhook.json"),
 		authentication: path.join(currentDir, "schemas", "authentication.json"),
+		documentation: path.join(currentDir, "Documentation.mdx"),
 	};
 
 	// Step-by-step validation
+	validateDocumentation(paths.documentation, errors);
+
 	const spec = validateSpec(paths.spec, errors);
-	validateDocumentation(currentDir, spec, errors);
 	validateWebhook(paths.webhook, spec, errors);
 	validateAuthentication(paths.authentication, errors);
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@boltic/cli",
-	"version": "1.0.27-1",
+	"version": "1.0.27",
 	"description": "A powerful CLI tool for managing Boltic Workflow integrations - create, sync, test, and publish integrations with ease",
 	"main": "index.js",
 	"bin": {
@@ -107,6 +107,7 @@
 		"@inquirer/prompts": "^7.8.0",
 		"axios": "^1.11.0",
 		"chalk": "^5.5.0",
+		"js-yaml": "^4.1.0",
 		"keytar": "^7.9.0",
 		"lodash.isempty": "^4.4.0",
 		"open": "^10.2.0",

package/helper/markdown.js

@@ -1,32 +0,0 @@
-import fs from "fs";
-
-const hasBalancedCodeFences = (content) => {
-	const fenceCount = (content.match(/```/g) || []).length;
-	return fenceCount % 2 === 0;
-};
-
-export const validateMarkdownString = (content, fileLabel, errors) => {
-	const label = fileLabel || "markdown";
-	if (!content || !content.trim()) {
-		errors.add(`"${label}" is empty.`);
-		return false;
-	}
-	// Keep checks minimal to avoid false positives in CLI usage
-	if (!hasBalancedCodeFences(content)) {
-		errors.add('"' + label + '" has unbalanced code fences (```).');
-	}
-	return true;
-};
-
-export const validateMarkdownFile = (filePath, errors, label) => {
-	try {
-		if (!fs.existsSync(filePath)) return false;
-		const content = fs.readFileSync(filePath, "utf8");
-		return validateMarkdownString(content, label || filePath, errors);
-	} catch (e) {
-		errors.add(
-			`Failed to read markdown file "${label || filePath}": ${e.message}`
-		);
-		return false;
-	}
-};