@boltic/cli 1.0.38 → 1.0.40

package/README.md

@@ -1,6 +1,6 @@
 # ⚡ Boltic CLI
 
-> **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.**
+> **Professional CLI for interacting with the Boltic platform — create, manage, and publish integrations, serverless functions, 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)
@@ -29,6 +29,7 @@
 - [🔐 Authentication](#-authentication)
 - [🧩 Integration Management](#-integration-management)
 - [🧠 MCP](#-mcp-model-context-protocol)
+- [⚡ Serverless Functions](#-serverless-functions)
 - [📚 Command Reference](#-command-reference)
 - [🛠️ Development Workflow](#️-development-workflow)
 - [🔧 Configuration](#-configuration)
@@ -44,6 +45,7 @@
 
 - 🔐 **Secure Authentication** - Enterprise-grade token management with secure storage
 - 🚀 **Rapid Development** - Create workflows, integrations, and more in minutes, not hours
+- ⚡ **Serverless Functions** - Deploy functions in Node.js, Python, Golang, or Java with local testing
 - 📦 **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
@@ -69,11 +71,14 @@ boltic login
 # Create your first integration
 boltic integration create
 
-# Sync your changes
-boltic integration sync
+# Or create a serverless function
+boltic serverless create --type blueprint --name my-api --language nodejs
 
-# Submit for review
-boltic integration submit
+# Test locally
+boltic serverless test
+
+# Deploy to Boltic Cloud
+boltic serverless publish
 ```
 
 ---
@@ -299,6 +304,107 @@ boltic mcp setup https://mcp.boltic.io/sse my-boltic --client claude
 
 ---
 
+## ⚡ Serverless Functions
+
+Create, test, and deploy serverless functions on the Boltic platform with support for multiple languages and deployment types.
+
+### Supported Languages
+
+| Language | Version | Handler |
+|----------|---------|---------|
+| Node.js  | 20      | `handler.handler` |
+| Python   | 3       | `index.handler` |
+| Golang   | 1.22    | `Handler` |
+| Java     | 17      | `Handler` |
+
+### Deployment Types
+
+| Type | Description |
+|------|-------------|
+| **Blueprint** | Write code directly in the CLI-generated project |
+| **Git** | Deploy from a Git repository |
+| **Container** | Deploy a Docker container |
+
+### Creating Serverless Functions
+
+```bash
+# Interactive mode (prompts for all options)
+boltic serverless create
+
+# Create a blueprint serverless function
+boltic serverless create --type blueprint --name my-api --language nodejs
+
+# Create a git-based serverless function
+boltic serverless create --type git --name my-git-func --language python
+
+# Create a container-based serverless function
+boltic serverless create --type container --name my-container
+
+# Specify custom directory
+boltic serverless create --type blueprint --name my-function --language python --directory ./projects
+```
+
+#### Generated Project Structure
+
+```
+my-serverless/
+├── boltic.yaml          # Configuration file with serverless settings
+├── handler.js           # Handler file (Node.js) or index.py (Python), etc.
+└── package.json         # Dependencies (for Node.js projects)
+```
+
+### Testing Locally
+
+```bash
+# Auto-detect language and run on default port (8080)
+boltic serverless test
+
+# Specify custom port
+boltic serverless test --port 3000
+
+# Test from specific directory
+boltic serverless test --directory ./my-function
+```
+
+### Publishing
+
+```bash
+# Publish from current directory
+boltic serverless publish
+
+# Publish from specific directory
+boltic serverless publish --directory ./my-function
+```
+
+### Pulling Existing Functions
+
+```bash
+# Pull a serverless function (interactive selection)
+boltic serverless pull
+
+# Pull to a specific path
+boltic serverless pull --path ./projects
+```
+
+### Listing Functions
+
+```bash
+# List all serverless functions
+boltic serverless list
+```
+
+### Checking Status
+
+```bash
+# Check status (interactive selection)
+boltic serverless status
+
+# Check status by name
+boltic serverless status --name my-function
+```
+
+---
+
 ## 📚 Command Reference
 
 ### Core Commands
@@ -329,6 +435,18 @@ boltic mcp setup https://mcp.boltic.io/sse my-boltic --client claude
 | `boltic mcp help`  | Show help for MCP sub-commands               |                                   |
 | `boltic mcp setup` | Configure an MCP server for a specific client| `--client <name>` `--name <alias>`|
 
+### Serverless Commands
+
+| Command                      | Description                          | Options                                              |
+| ---------------------------- | ------------------------------------ | ---------------------------------------------------- |
+| `boltic serverless create`   | Create a new serverless function     | `--type, -t` `--name, -n` `--language, -l` `--directory, -d` |
+| `boltic serverless test`     | Test serverless function locally     | `--port, -p` `--language, -l` `--directory, -d`      |
+| `boltic serverless publish`  | Publish/deploy serverless function   | `--directory, -d`                                    |
+| `boltic serverless pull`     | Pull existing serverless function    | `--path`                                             |
+| `boltic serverless list`     | List all serverless functions        |                                                      |
+| `boltic serverless status`   | Show status of a serverless function | `--name, -n`                                         |
+| `boltic serverless help`     | Show help for serverless commands    |                                                      |
+
 ### Help and Documentation
 
 ```bash

package/api/serverless.js

@@ -0,0 +1,174 @@
+import axios from "axios";
+import FormData from "form-data";
+import fs from "fs";
+import https from "https";
+import { handleError } from "../helper/error.js";
+import { logApi } from "../helper/verbose.js";
+
+const getHttpsAgentForUrl = (baseUrl) => {
+	try {
+		const host = new URL(baseUrl).hostname;
+		if (
+			host.endsWith("fcz0.de") ||
+			host.endsWith("uat.fcz0.de") ||
+			host.endsWith("fyndx1.de") ||
+			process.env.BOLTCI_INSECURE_TLS === "true"
+		) {
+			return new https.Agent({ rejectUnauthorized: false });
+		}
+	} catch (_) {
+		// ignore URL parse errors and fall back to default agent
+	}
+	return undefined;
+};
+
+const listAllServerless = async (
+	apiUrl,
+	token,
+	accountId,
+	session,
+	query = null
+) => {
+	if (!token || !session || !accountId) {
+		console.error(
+			"\x1b[31mError:\x1b[0m Authentication credentials are required."
+		);
+		console.log("\n🔹 Please log in first using:");
+		console.log("\x1b[32m$ boltic login\x1b[0m\n");
+		process.exit(1); // Exit the CLI with an error code
+	}
+	try {
+		const params = {
+			page: 1,
+			limit: 999,
+			sortBy: "CreatedAt",
+			sortOrder: "desc",
+		};
+
+		// Add query parameter if provided
+		if (query) {
+			params.q = query;
+		}
+
+		const axiosOptions = {
+			method: "get",
+			url: `${apiUrl}/service/panel/serverless/v1.0/apps`,
+			params,
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${token}`,
+				Cookie: session,
+			},
+			httpsAgent: getHttpsAgentForUrl(apiUrl),
+		};
+
+		const response = await axios(axiosOptions);
+		logApi(axiosOptions.method, axiosOptions.url, response.status);
+		return response.data.data;
+	} catch (error) {
+		handleError(error);
+	}
+};
+
+const pullServerless = async (apiUrl, token, accountId, session, id) => {
+	if (!token || !session || !accountId) {
+		console.error(
+			"\x1b[31mError:\x1b[0m Authentication credentials are required."
+		);
+		console.log("\n🔹 Please log in first using:");
+		console.log("\x1b[32m$ boltic login\x1b[0m\n");
+		process.exit(1); // Exit the CLI with an error code
+	}
+	try {
+		const response = await axios({
+			method: "get",
+			url: `${apiUrl}/service/panel/serverless/v1.0/apps/${id}`,
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${token}`,
+				Cookie: session,
+			},
+			httpsAgent: getHttpsAgentForUrl(apiUrl),
+		});
+		return response?.data;
+	} catch (error) {
+		handleError(error);
+	}
+};
+
+const publishServerless = async (apiUrl, token, session, payload) => {
+	if (!token || !session) {
+		console.error(
+			"\x1b[31mError:\x1b[0m Authentication credentials are required."
+		);
+		console.log("\n🔹 Please log in first using:");
+		console.log("\x1b[32m$ boltic login\x1b[0m\n");
+		process.exit(1);
+	}
+
+	try {
+		const axiosOptions = {
+			method: "post",
+			url: `https://asia-south1.api.boltic.io/service/panel/serverless/v1.0/apps`,
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${token}`,
+				Cookie: session,
+			},
+			data: payload,
+			httpsAgent: getHttpsAgentForUrl(apiUrl),
+		};
+
+		const response = await axios(axiosOptions);
+		logApi(axiosOptions.method, axiosOptions.url, response.status);
+		return response.data;
+	} catch (error) {
+		handleError(error);
+		return null;
+	}
+};
+
+const updateServerless = async (
+	apiUrl,
+	token,
+	session,
+	serverlessId,
+	payload
+) => {
+	if (!token || !session) {
+		console.error(
+			"\x1b[31mError:\x1b[0m Authentication credentials are required."
+		);
+		console.log("\n🔹 Please log in first using:");
+		console.log("\x1b[32m$ boltic login\x1b[0m\n");
+		process.exit(1);
+	}
+
+	try {
+		const axiosOptions = {
+			method: "put",
+			url: `https://asia-south1.api.boltic.io/service/panel/serverless/v1.0/apps/${serverlessId}`,
+			headers: {
+				"Content-Type": "application/json",
+				Authorization: `Bearer ${token}`,
+				Cookie: session,
+			},
+			data: payload,
+			httpsAgent: getHttpsAgentForUrl(apiUrl),
+		};
+
+		const response = await axios(axiosOptions);
+		logApi(axiosOptions.method, axiosOptions.url, response.status);
+		return response.data;
+	} catch (error) {
+		handleError(error);
+		return null;
+	}
+};
+
+export {
+	listAllServerless,
+	pullServerless,
+	publishServerless,
+	updateServerless,
+};

package/cli.js

@@ -6,6 +6,7 @@ import EnvironmentCommands from "./commands/env.js";
 import IntegrationCommands from "./commands/integration.js";
 import AuthCommands from "./commands/login.js";
 import McpCommands from "./commands/mcp.js";
+import ServerlessCommands from "./commands/serverless.js";
 
 // Create a CLI module with functional approach
 import { findSimilarCommands } from "./helper/command-suggestions.js";
@@ -17,9 +18,69 @@ const createCLI = (consoleUrl, apiUrl, serviceName, env) => {
 		login: {
 			description: "Authenticate the user and save access token",
 			action: async (args) => {
-				// Support PAT-based login via flag: `boltic login --pat`
-				if (args.includes("--pat")) {
-					await AuthCommands.handlePatLogin();
+				// Support PAT-based login via flags, e.g.:
+				//   boltic login --pat XXXXX --account_id YYYYYY
+				//   boltic login --pat=XXXXX --account-id=YYYYYY
+				let patFromArg;
+				let accountIdFromArg;
+				let hasPatFlag = false;
+				let hasAccountIdFlag = false;
+
+				for (let i = 0; i < args.length; i++) {
+					const arg = args[i];
+
+					if (arg === "--pat") {
+						hasPatFlag = true;
+						if (
+							i + 1 < args.length &&
+							!args[i + 1].startsWith("--")
+						) {
+							patFromArg = args[i + 1];
+							i++;
+						}
+						continue;
+					}
+
+					if (arg === "--account_id" || arg === "--account-id") {
+						hasAccountIdFlag = true;
+						if (
+							i + 1 < args.length &&
+							!args[i + 1].startsWith("--")
+						) {
+							accountIdFromArg = args[i + 1];
+							i++;
+						}
+						continue;
+					}
+
+					if (arg.startsWith("--pat=")) {
+						hasPatFlag = true;
+						patFromArg = arg.split("=")[1];
+						continue;
+					}
+
+					if (
+						arg.startsWith("--account_id=") ||
+						arg.startsWith("--account-id=")
+					) {
+						hasAccountIdFlag = true;
+						accountIdFromArg = arg.split("=")[1];
+						continue;
+					}
+				}
+
+				// If any PAT-related flag is present, delegate to PAT login handler.
+				// `handlePatLogin` will decide whether to prompt based on which values are provided.
+				if (
+					hasPatFlag ||
+					hasAccountIdFlag ||
+					patFromArg ||
+					accountIdFromArg
+				) {
+					await AuthCommands.handlePatLogin(
+						patFromArg,
+						accountIdFromArg
+					);
 					return;
 				}
 
@@ -50,6 +111,10 @@ const createCLI = (consoleUrl, apiUrl, serviceName, env) => {
 			description: "Display the version of the CLI.",
 			action: () => showVersion(),
 		},
+		serverless: {
+			description: "Manage serverless (create, list, test)",
+			action: (args) => handleServerless(args),
+		},
 	};
 
 	return {
@@ -175,6 +240,9 @@ async function handleMcp(args) {
 	await McpCommands.execute(args);
 }
 
+async function handleServerless(args) {
+	await ServerlessCommands.execute(args);
+}
 async function showVersion() {
 	let version = "1.0.0";
 	try {

package/commands/login.js

@@ -29,6 +29,55 @@ const execute = async (args) => {
 		return;
 	}
 
+	// Special handling for `boltic login` to support PAT-based login via flags:
+	//   boltic login --pat XXXXX --account_id YYYYYY
+	if (subCommand === "login") {
+		const options = args.slice(1);
+		let patFromArg;
+		let accountIdFromArg;
+
+		for (let i = 0; i < options.length; i++) {
+			const arg = options[i];
+
+			if (arg === "--pat" && i + 1 < options.length) {
+				patFromArg = options[i + 1];
+				i++;
+				continue;
+			}
+
+			if (
+				(arg === "--account_id" || arg === "--account-id") &&
+				i + 1 < options.length
+			) {
+				accountIdFromArg = options[i + 1];
+				i++;
+				continue;
+			}
+
+			if (arg.startsWith("--pat=")) {
+				patFromArg = arg.split("=")[1];
+				continue;
+			}
+
+			if (
+				arg.startsWith("--account_id=") ||
+				arg.startsWith("--account-id=")
+			) {
+				accountIdFromArg = arg.split("=")[1];
+				continue;
+			}
+		}
+
+		// If PAT flags are provided, use PAT-based login. Otherwise, fall back to browser-based login.
+		if (patFromArg || accountIdFromArg) {
+			await handlePatLogin(patFromArg, accountIdFromArg);
+			return;
+		}
+
+		await handleLogin();
+		return;
+	}
+
 	await commands[subCommand].action(args.slice(1));
 };
 
@@ -179,31 +228,51 @@ async function handleLogin() {
 
 // Handle PAT-based login command
 async function handlePatLogin(patFromArg, accountIdFromArg) {
-	let pat = patFromArg;
-	let accountId = accountIdFromArg;
+	let pat = patFromArg && patFromArg.trim();
+	let accountId = accountIdFromArg && accountIdFromArg.trim();
+
+	// If both values are provided via CLI flags, do not prompt at all.
+	if (pat && accountId) {
+		try {
+			await storeSecret("pat", pat);
+			await storeSecret("account_id", accountId);
+			console.log(
+				chalk.green(
+					"\n✅ PAT token and Account ID stored securely. They will be used for future organization-related requests.\n"
+				)
+			);
+		} catch (error) {
+			console.error(
+				chalk.red(
+					`\n❌ Failed to store PAT credentials: ${error.message || error}\n`
+				)
+			);
+		}
+		return;
+	}
 
 	if (!pat) {
 		console.log(chalk.cyan("\n🔐 Personal Access Token (PAT) login\n"));
-		pat = await askQuestion("Enter your PAT token: ");
+		pat = (await askQuestion("Enter your PAT token: ")).trim();
 	}
 
-	if (!pat || !pat.trim()) {
+	if (!pat) {
 		console.log(chalk.red("\n❌ PAT token cannot be empty.\n"));
 		return;
 	}
 
 	if (!accountId) {
-		accountId = await askQuestion("Enter your Account ID: ");
+		accountId = (await askQuestion("Enter your Account ID: ")).trim();
 	}
 
-	if (!accountId || !accountId.trim()) {
+	if (!accountId) {
 		console.log(chalk.red("\n❌ Account ID cannot be empty.\n"));
 		return;
 	}
 
 	try {
-		await storeSecret("pat", pat.trim());
-		await storeSecret("account_id", accountId.trim());
+		await storeSecret("pat", pat);
+		await storeSecret("account_id", accountId);
 		console.log(
 			chalk.green(
 				"\n✅ PAT token and Account ID stored securely. They will be used for future organization-related requests.\n"