@boltic/cli 0.0.1

package/commands/login.js

@@ -0,0 +1,170 @@
+import chalk from "chalk";
+import open from "open";
+import { v4 as uuidv4 } from "uuid";
+import { getCliBearerToken, getCliSession } from "../api/login.js";
+import { getCurrentEnv } from "../helper/env.js";
+import { deleteAllSecrets, storeSecret } from "../helper/secure-storage.js";
+
+// Define login commands and their actions
+const commands = {
+	login: {
+		description: "Login to the platform and save access token",
+		action: handleLogin,
+	},
+	logout: {
+		description: "Logout and clear access token",
+		action: handleLogout,
+	},
+	help: { description: "Show help for login commands", action: showHelp },
+};
+
+// Execute a command
+const execute = async (args) => {
+	const subCommand = args[0];
+
+	if (!subCommand || !commands[subCommand]) {
+		console.log(chalk.red("❌ Unknown or missing login sub-command.\n"));
+		showHelp();
+		return;
+	}
+
+	await commands[subCommand].action(args.slice(1));
+};
+
+// Show available login commands
+function showHelp() {
+	console.log(chalk.cyan("\nLogin Commands:\n"));
+	Object.entries(commands).forEach(([cmd, details]) =>
+		console.log(chalk.bold(`${cmd}`) + ` - ${details.description}`)
+	);
+}
+
+// Handle login command
+async function handleLogin(args) {
+	const { apiUrl, loginUrl, clientId, frontendUrl } = await getCurrentEnv();
+
+	const requestCode = uuidv4();
+	const state = {
+		source: "boltic_cli",
+		request_code: requestCode,
+	};
+
+	const loginPage = new URL(`${loginUrl}/auth/sign-in`);
+	loginPage.searchParams.append("client_id", clientId);
+	loginPage.searchParams.append("redirect_uri", frontendUrl);
+	loginPage.searchParams.append("state", JSON.stringify(state));
+
+	console.log(chalk.cyan("\n🌐 Opening browser for login..."));
+	try {
+		await open(loginPage.toString());
+		console.log(chalk.cyan("✅ Browser launched successfully"));
+	} catch (error) {
+		console.error(
+			chalk.red(
+				`\n❌ Failed to open browser automatically: ${error.message}`
+			)
+		);
+		console.log(
+			chalk.yellow("\n📋 Please copy and paste this URL in your browser:")
+		);
+		console.log(chalk.cyan("\n" + loginPage.toString() + "\n"));
+	}
+
+	const startTime = Date.now();
+	const timeout = 300000; // 5 minutes in milliseconds
+	const pollInterval = 5000; // 5 seconds
+
+	let lastProgressUpdate = 0;
+	console.log(chalk.cyan("\n⏳ Waiting for authentication..."));
+
+	while (Date.now() - startTime < timeout) {
+		try {
+			const sessionResponse = await getCliSession(apiUrl, requestCode);
+
+			if (!sessionResponse?.data?.data) {
+				const now = Date.now();
+				if (now - lastProgressUpdate >= pollInterval) {
+					process.stdout.write(chalk.yellow("."));
+					lastProgressUpdate = now;
+				}
+				continue;
+			}
+
+			const { account_id: accountId, session } =
+				sessionResponse.data.data;
+
+			if (!accountId || !session) {
+				console.log(
+					chalk.yellow(
+						"\n⚠️ Invalid session data received, retrying..."
+					)
+				);
+				continue;
+			}
+
+			try {
+				await storeSecret(
+					"session",
+					`bolt.session=${encodeURIComponent(session)}`
+				);
+				await storeSecret("account_id", accountId);
+
+				const token = await getCliBearerToken(
+					apiUrl,
+					accountId,
+					session
+				);
+
+				if (!token?.data?.data?.token) {
+					throw new Error("Invalid token response");
+				}
+
+				await storeSecret("token", token.data.data.token);
+				console.log(chalk.green("\n✅ Login successful!"));
+				return;
+			} catch (storageError) {
+				console.error(
+					chalk.red(
+						`\n❌ Failed to store authentication data: ${storageError.message}`
+					)
+				);
+				return;
+			}
+		} catch (error) {
+			if (error?.response?.status === 401) {
+				console.error(
+					chalk.red("\n\n❌ Authentication failed. Please try again.")
+				);
+				return;
+			} else if (error?.code === "ECONNREFUSED") {
+				console.error(
+					chalk.red("\n\n❌ Cannot connect to authentication server.")
+				);
+				return;
+			} else if (error?.response?.status !== 404) {
+				const now = Date.now();
+				if (now - lastProgressUpdate >= pollInterval) {
+					process.stdout.write(chalk.yellow("x"));
+					lastProgressUpdate = now;
+				}
+			}
+		}
+
+		await new Promise((resolve) => setTimeout(resolve, pollInterval));
+	}
+
+	console.error(
+		chalk.red("\n❌ Login timeout after 5 minutes. Please try again.")
+	);
+}
+
+// Handle logout command
+async function handleLogout() {
+	await deleteAllSecrets();
+	console.log(
+		chalk.bgGreen.black("\n ✅ Success! ") +
+			chalk.green(" Logout successful! All user data cleared.\n")
+	);
+}
+
+export default { execute, handleLogin, handleLogout };

package/config/environments.js

@@ -0,0 +1,13 @@
+const environments = {
+	bolt: {
+		name: "boltic",
+		consoleUrl: "https://api.console.fynd.com",
+		apiUrl: "https://asia-south1.api.boltic.io",
+		loginUrl: "https://console.fynd.com",
+		clientId: "40ec7873-ce38-4f0a-923b-1ebe96887d78",
+		allowedOrigin: "*.console.boltic.io",
+		frontendUrl: "https://asia-south1.console.boltic.io",
+	},
+};
+
+export { environments };

package/helper/command-suggestions.js

@@ -0,0 +1,54 @@
+// Helper function to calculate Levenshtein distance between two strings
+function levenshteinDistance(str1, str2) {
+	const m = str1.length;
+	const n = str2.length;
+	const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+
+	for (let i = 0; i <= m; i++) dp[i][0] = i;
+	for (let j = 0; j <= n; j++) dp[0][j] = j;
+
+	for (let i = 1; i <= m; i++) {
+		for (let j = 1; j <= n; j++) {
+			if (str1[i - 1] === str2[j - 1]) {
+				dp[i][j] = dp[i - 1][j - 1];
+			} else {
+				dp[i][j] =
+					Math.min(
+						dp[i - 1][j - 1], // substitution
+						dp[i - 1][j], // deletion
+						dp[i][j - 1] // insertion
+					) + 1;
+			}
+		}
+	}
+
+	return dp[m][n];
+}
+
+// Find similar commands based on Levenshtein distance and prefix matching
+export function findSimilarCommands(invalidCommand, availableCommands) {
+	const threshold = 3; // Maximum distance to consider as similar
+	const suggestions = new Set(); // Use Set to avoid duplicates
+	const lowerInvalidCmd = invalidCommand.toLowerCase();
+
+	for (const cmd of Object.keys(availableCommands)) {
+		const lowerCmd = cmd.toLowerCase();
+
+		// Check for prefix match first
+		if (
+			lowerCmd.startsWith(lowerInvalidCmd) ||
+			lowerInvalidCmd.startsWith(lowerCmd)
+		) {
+			suggestions.add(cmd);
+			continue;
+		}
+
+		// If no prefix match, check Levenshtein distance
+		const distance = levenshteinDistance(lowerInvalidCmd, lowerCmd);
+		if (distance <= threshold) {
+			suggestions.add(cmd);
+		}
+	}
+
+	return Array.from(suggestions);
+}

package/helper/env.js

@@ -0,0 +1,27 @@
+import { environments } from "../config/environments.js";
+import { getAllSecrets } from "./secure-storage.js";
+
+/**
+ * Get current environment and tokens from config
+ * @returns {Object} Environment configuration including apiUrl, token, session, and accountId
+ */
+export const getCurrentEnv = async () => {
+	const secrets = await getAllSecrets();
+	let config;
+	if (secrets && secrets.length > 0) {
+		config = secrets.reduce((acc, { account, password }) => {
+			acc[account] = password;
+			return acc;
+		}, {});
+	}
+	return {
+		apiUrl: environments.bolt.apiUrl,
+		loginUrl: environments.bolt.loginUrl,
+		consoleUrl: environments.bolt.consoleUrl,
+		clientId: environments.bolt.clientId,
+		token: config?.token || null,
+		session: config?.session || null,
+		accountId: config?.account_id || null,
+		frontendUrl: environments.bolt.frontendUrl,
+	};
+};

package/helper/error.js

@@ -0,0 +1,123 @@
+import chalk from "chalk";
+
+// Error types for different scenarios
+const ErrorType = {
+	API_ERROR: "API_ERROR",
+	NETWORK_ERROR: "NETWORK_ERROR",
+	AUTH_ERROR: "AUTH_ERROR",
+	VALIDATION_ERROR: "VALIDATION_ERROR",
+	CONFIG_ERROR: "CONFIG_ERROR",
+	UNKNOWN_ERROR: "UNKNOWN_ERROR",
+};
+
+// Format error message based on error type and response
+const formatErrorMessage = (error) => {
+	if (!error)
+		return {
+			type: ErrorType.UNKNOWN_ERROR,
+			message: "An unknown error occurred",
+		};
+
+	// Handle API response errors
+	if (error.response) {
+		const { status, data } = error.response;
+
+		// Authentication errors
+		if (status === 401 || status === 403) {
+			return {
+				type: ErrorType.AUTH_ERROR,
+				message:
+					data.message ||
+					"Authentication failed. Please login again.",
+			};
+		}
+
+		// Validation errors
+		if (status === 400) {
+			return {
+				type: ErrorType.VALIDATION_ERROR,
+				message:
+					data.message || "Invalid request. Please check your input.",
+			};
+		}
+
+		// Server errors
+		if (status >= 500) {
+			return {
+				type: ErrorType.API_ERROR,
+				message:
+					error.response?.data?.error?.message ||
+					"Server error occurred. Please try again later.",
+			};
+		}
+
+		// Default API error
+		return {
+			type: ErrorType.API_ERROR,
+			message: data.message || `API Error: ${status}`,
+		};
+	}
+
+	// Network errors
+	if (error.code === "ECONNREFUSED" || error.code === "ENOTFOUND") {
+		return {
+			type: ErrorType.NETWORK_ERROR,
+			message:
+				"Unable to connect to the server. Please check your internet connection.",
+		};
+	}
+
+	// Configuration errors
+	if (error.code === "ENOENT") {
+		return {
+			type: ErrorType.CONFIG_ERROR,
+			message: "Configuration file not found. Please run setup again.",
+		};
+	}
+
+	// Default unknown error
+	return {
+		type: ErrorType.UNKNOWN_ERROR,
+		message: error.message || "An unexpected error occurred",
+	};
+};
+
+// Display formatted error message to user
+const handleError = (error) => {
+	const formattedError = formatErrorMessage(error);
+
+	switch (formattedError.type) {
+		case ErrorType.AUTH_ERROR:
+			console.error(
+				chalk.red("\n❌ Authentication Error:"),
+				formattedError.message
+			);
+			break;
+		case ErrorType.API_ERROR:
+			console.error(chalk.red("\n❌ API Error:"), formattedError.message);
+			break;
+		case ErrorType.NETWORK_ERROR:
+			console.error(
+				chalk.red("\n❌ Network Error:"),
+				formattedError.message
+			);
+			break;
+		case ErrorType.VALIDATION_ERROR:
+			console.error(
+				chalk.red("\n❌ Validation Error:"),
+				formattedError.message
+			);
+			break;
+		case ErrorType.CONFIG_ERROR:
+			console.error(
+				chalk.red("\n❌ Configuration Error:"),
+				formattedError.message
+			);
+			break;
+		default:
+			console.error(chalk.red("\n❌ Error:"), formattedError.message);
+	}
+	process.exit(1);
+};
+
+export { ErrorType, handleError };

package/helper/folder.js

@@ -0,0 +1,204 @@
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import {
+	authentication,
+	base,
+	resource1,
+	webhook,
+} from "../templates/schemas.js";
+
+export const createIntegrationFolderStructure = async (integration) => {
+	const { id, name, description, icon, activity_type, trigger_type, meta } =
+		integration;
+
+	const spec = {
+		id,
+		name,
+		description,
+		icon,
+		activity_type,
+		trigger_type,
+		meta,
+	};
+	// Create integration folder structure
+	const integrationName = name.toLowerCase().replace(/\s+/g, "-");
+	const integrationDir = path.join(process.cwd(), integrationName);
+
+	// Ensure the integration directory doesn't exist
+	if (fs.existsSync(integrationDir)) {
+		console.log(
+			chalk.yellow(
+				`\nWarning: Directory ${integrationDir} already exists!`
+			)
+		);
+		return integrationDir;
+	}
+
+	// Create main directory
+	fs.mkdirSync(integrationDir, { recursive: true });
+
+	// Create schemas directory and its subdirectories
+	const schemasDir = path.join(integrationDir, "schemas");
+	const resourcesDir = path.join(schemasDir, "resources");
+	fs.mkdirSync(resourcesDir, { recursive: true });
+
+	// Create template files
+	const files = {
+		"schemas/resources/resource1.json": JSON.stringify(resource1, null, 4),
+		"schemas/authentication.json": JSON.stringify(authentication, null, 4),
+		"schemas/base.json": JSON.stringify(base(name), null, 4),
+		"schemas/webhook.json": JSON.stringify(webhook(name), null, 4),
+		"spec.json": JSON.stringify(spec, null, 4),
+		"Authentication.mdx": `# ${name} Authentication
+
+Describe the authentication process for ${name} integration here.`,
+		"Documentation.mdx": `# ${name} Documentation
+
+${description}
+
+## Overview
+
+Add integration overview here.
+
+## Features
+
+- Feature 1
+- Feature 2
+- Feature 3
+
+## Setup Guide
+
+1. Step 1
+2. Step 2
+3. Step 3`,
+	};
+
+	// Create all files
+	for (const [filePath, content] of Object.entries(files)) {
+		const fullPath = path.join(integrationDir, filePath);
+		fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+		fs.writeFileSync(fullPath, content);
+	}
+
+	console.log(chalk.cyan(`To navigate to your integration folder, run:\n`));
+	console.log(chalk.white(`  cd ${integrationName}\n`));
+};
+
+export const createExistingIntegrationsFolder = async (payload) => {
+	const {
+		integration,
+		authentication,
+		webhook,
+		configuration,
+		resources,
+		operations,
+	} = payload;
+
+	const {
+		id,
+		name,
+		description,
+		icon,
+		activity_type,
+		trigger_type,
+		documentation,
+		meta,
+	} = integration;
+
+	const spec = {
+		id,
+		name,
+		description,
+		icon,
+		activity_type,
+		trigger_type,
+		meta,
+	};
+
+	const integrationName = name.toLowerCase().replace(/\s+/g, "-");
+	const integrationDir = path.join(process.cwd(), integrationName);
+
+	// Log if the directory already exists
+	if (fs.existsSync(integrationDir)) {
+		console.log(
+			chalk.yellow(
+				`\nNotice: Directory ${integrationDir} already exists. Updating contents...\n`
+			)
+		);
+	} else {
+		console.log(
+			chalk.green(`\nCreating integration directory: ${integrationDir}\n`)
+		);
+	}
+
+	// Ensure all necessary folders exist
+	fs.mkdirSync(integrationDir, { recursive: true });
+
+	const schemasDir = path.join(integrationDir, "schemas");
+	const resourcesDir = path.join(schemasDir, "resources");
+	fs.mkdirSync(resourcesDir, { recursive: true });
+
+	const authentication_documentation = authentication.documentation;
+
+	// Define files and content
+	const files = {
+		"schemas/authentication.json": JSON.stringify(
+			authentication.content || {},
+			null,
+			4
+		),
+		"schemas/base.json": JSON.stringify(
+			configuration?.content || {},
+			null,
+			4
+		),
+		"schemas/webhook.json": JSON.stringify(webhook?.content || {}, null, 4),
+		"spec.json": JSON.stringify(spec, null, 4),
+		"Authentication.mdx": authentication_documentation || "",
+		"Documentation.mdx": documentation || "",
+	};
+
+	// Write resource files
+	resources.forEach((resource) => {
+		const resource_id = resource.id;
+		const resourceName = resource.name.toLowerCase().replace(/\s+/g, "-");
+		const resourcePath = path.join(resourcesDir, `${resourceName}.json`);
+
+		const resourceOperations = operations.filter(
+			(operation) => operation.resource_id === resource_id
+		);
+
+		const operationsContent = resourceOperations.reduce(
+			(acc, operation) => {
+				const operationName = operation.name
+					.toLowerCase()
+					.replace(/\s+/g, "-");
+				acc[operationName] = operation.content;
+				return acc;
+			},
+			{}
+		);
+
+		const resourceFileContent = {
+			...resource.content,
+			...operationsContent,
+		};
+
+		fs.writeFileSync(
+			resourcePath,
+			JSON.stringify(resourceFileContent, null, 4)
+		);
+	});
+
+	// Write or overwrite all defined files
+	for (const [filePath, content] of Object.entries(files)) {
+		const fullPath = path.join(integrationDir, filePath);
+		fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+		fs.writeFileSync(fullPath, content);
+	}
+
+	console.log(chalk.cyan(`\nIntegration folder is ready at:`));
+	console.log(chalk.white(`  ${integrationDir}\n`));
+	return true;
+};

package/helper/secure-storage.js

@@ -0,0 +1,74 @@
+import keytar from "keytar";
+
+const SERVICE_NAME = "boltic-cli";
+
+/**
+ * Store a secret value securely using keytar
+ * @param {string} key - The key under which to store the secret
+ * @param {string} value - The secret value to store
+ * @returns {Promise<void>}
+ */
+export const storeSecret = async (key, value) => {
+	try {
+		await keytar.setPassword(SERVICE_NAME, key, value);
+	} catch (error) {
+		console.error(`Error storing secret for ${key}:`, error.message);
+		throw error;
+	}
+};
+
+/**
+ * Retrieve a secret value using keytar
+ * @param {string} key - The key of the secret to retrieve
+ * @returns {Promise<string|null>} The secret value or null if not found
+ */
+export const getSecret = async (key) => {
+	try {
+		return await keytar.getPassword(SERVICE_NAME, key);
+	} catch (error) {
+		console.error(`Error retrieving secret for ${key}:`, error.message);
+		return null;
+	}
+};
+
+/**
+ * Delete a secret value using keytar
+ * @param {string} key - The key of the secret to delete
+ * @returns {Promise<boolean>} True if deletion was successful
+ */
+export const deleteSecret = async (key) => {
+	try {
+		return await keytar.deletePassword(SERVICE_NAME, key);
+	} catch (error) {
+		console.error(`Error deleting secret for ${key}:`, error.message);
+		return false;
+	}
+};
+
+/**
+ * Retrieve all secrets stored using keytar
+ * @returns {Promise<Array<{account: string, password: string}>|null>} An array of secret objects or null if an error occurs
+ */
+
+export const getAllSecrets = async () => {
+	try {
+		return await keytar.findCredentials(SERVICE_NAME);
+	} catch (error) {
+		console.error(`Error retrieving all secrets:`, error.message);
+		return null;
+	}
+};
+
+export const deleteAllSecrets = async () => {
+	try {
+		const secrets = await getAllSecrets();
+		if (secrets && secrets.length > 0) {
+			const deletionPromises = secrets.map(
+				async ({ account }) => await deleteSecret(account)
+			);
+			await Promise.all(deletionPromises);
+		}
+	} catch (error) {
+		console.error(`Error deleting all secrets:`, error.message);
+	}
+};

package/helper/verbose.js

@@ -0,0 +1,20 @@
+import chalk from "chalk";
+
+let isVerbose = false;
+
+export const setVerboseMode = (verbose) => {
+	isVerbose = verbose;
+};
+
+export const getVerboseMode = () => {
+	return isVerbose;
+};
+
+export const logApi = (method, url, status) => {
+	if (!isVerbose) return;
+	console.log(
+		chalk(
+			`https fetch ${chalk.cyan(method.toUpperCase())} ${chalk.green(status)} ${chalk.yellow(url)}`
+		)
+	);
+};

package/index.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+import createCLI from "./cli.js";
+import { environments } from "./config/environments.js";
+
+// Get environment-specific URLs
+const env = environments.bolt;
+const FYND_CONSOLE_URL = env.consoleUrl;
+const BOLTIC_API_URL = env.apiUrl;
+
+(async () => {
+	const cli = createCLI(FYND_CONSOLE_URL, BOLTIC_API_URL, env);
+	await cli.execute(process.argv);
+})();