@boltic/cli 1.0.41 → 1.0.43

package/commands/serverless.js

@@ -15,6 +15,7 @@ import {
 	parseTestArgs,
 	parsePublishArgs,
 	createServerlessFiles,
+	createGitignore,
 	loadBolticConfig,
 	parseLanguageFromConfig,
 	parseHandlerConfig,
@@ -38,7 +39,11 @@ import {
 	pullServerless,
 	publishServerless,
 	updateServerless,
+	getServerlessBuilds,
+	getServerlessLogs,
+	getBuildLogs,
 } from "../api/serverless.js";
+import { setVerboseMode } from "../helper/verbose.js";
 
 // Define commands and their descriptions
 const commands = {
@@ -58,10 +63,6 @@ const commands = {
 		description: "Test a serverless function locally",
 		action: handleTest,
 	},
-	help: {
-		description: "Show help for serverless commands",
-		action: showHelp,
-	},
 	list: {
 		description: "List all serverless functions",
 		action: handleList,
@@ -70,6 +71,22 @@ const commands = {
 		description: "Show status of a serverless function",
 		action: handleStatus,
 	},
+	builds: {
+		description: "List builds for a serverless function",
+		action: handleBuilds,
+	},
+	logs: {
+		description: "Show logs for a serverless function",
+		action: handleLogs,
+	},
+	"build logs": {
+		description: "Show logs for a specific build",
+		action: handleBuildLogs,
+	},
+	help: {
+		description: "Show help for serverless commands",
+		action: showHelp,
+	},
 };
 
 // Serverless type choices for dropdown
@@ -92,7 +109,7 @@ async function handleCreate(args = []) {
 
 		// Step 1: Parse CLI arguments
 		const parsedArgs = parseCreateArgs(args);
-		let { name, language, directory, type } = parsedArgs;
+		let { name, language, directory, type, noGitignore } = parsedArgs;
 
 		// Step 2: Serverless Type Selection
 		if (!type) {
@@ -204,18 +221,30 @@ async function handleCreate(args = []) {
 		// Branch based on type
 		if (type === "git") {
 			// For git type: create empty folder with boltic.yaml only
-			await handleGitTypeCreate(name, language, version, targetDir);
+			await handleGitTypeCreate(
+				name,
+				language,
+				version,
+				targetDir,
+				noGitignore
+			);
 			return;
 		}
 
 		if (type === "container") {
 			// For container type: ask for image and create serverless
-			await handleContainerTypeCreate(name, targetDir);
+			await handleContainerTypeCreate(name, targetDir, noGitignore);
 			return;
 		}
 
 		// For code type: create full template files and call create API
-		await handleCodeTypeCreate(name, language, version, targetDir);
+		await handleCodeTypeCreate(
+			name,
+			language,
+			version,
+			targetDir,
+			noGitignore
+		);
 	} catch (error) {
 		if (
 			error.message &&
@@ -232,10 +261,87 @@ async function handleCreate(args = []) {
 	}
 }
 
+/**
+ * Check if a serverless function with the given name already exists
+ * @returns {Object|null} The existing serverless object if found, null otherwise
+ */
+async function checkServerlessExists(name) {
+	const env = await getCurrentEnv();
+	if (!env || !env.token || !env.session) {
+		return null; // Can't check without auth, let the create call handle auth error
+	}
+
+	const { apiUrl, token, accountId, session } = env;
+
+	try {
+		const allServerless = await listAllServerless(
+			apiUrl,
+			token,
+			accountId,
+			session,
+			name // Use query parameter to search by name
+		);
+
+		if (allServerless && Array.isArray(allServerless)) {
+			// Find exact match by name (case-insensitive)
+			const existing = allServerless.find(
+				(s) => s.Name && s.Name.toLowerCase() === name.toLowerCase()
+			);
+			return existing || null;
+		}
+	} catch {
+		// If API call fails, let the create call handle it
+		return null;
+	}
+
+	return null;
+}
+
+/**
+ * Display message when serverless already exists and suggest pull command
+ */
+function displayServerlessExistsMessage(name, existing) {
+	console.log(
+		chalk.yellow(
+			`\n⚠️  A serverless function named "${name}" already exists.`
+		)
+	);
+	console.log(chalk.dim(`   ID: ${existing.ID || existing._id}`));
+	if (existing.Status) {
+		console.log(chalk.dim(`   Status: ${existing.Status}`));
+	}
+	console.log();
+	console.log(chalk.cyan("To pull the existing serverless function, run:"));
+	console.log(chalk.green(`   boltic serverless pull --name ${name}`));
+	console.log();
+	console.log(chalk.dim("Or use a different name:"));
+	console.log(chalk.dim(`   boltic serverless create --name <new-name> ...`));
+	console.log();
+}
+
 /**
  * Handle code type serverless creation - creates folder with template files and calls create API
  */
-async function handleCodeTypeCreate(name, language, version, targetDir) {
+async function handleCodeTypeCreate(
+	name,
+	language,
+	version,
+	targetDir,
+	noGitignore = false
+) {
+	// Check if serverless with this name already exists
+	const existingServerless = await checkServerlessExists(name);
+	if (existingServerless) {
+		displayServerlessExistsMessage(name, existingServerless);
+		// Cleanup the created directory
+		try {
+			fs.rmSync(targetDir, { recursive: true, force: true });
+		} catch {
+			// Ignore cleanup errors
+		}
+		return;
+	}
+
 	const templateContext = {
 		AppSlug: name,
 		Language: `${language}/${version}`,
@@ -263,6 +369,14 @@ async function handleCodeTypeCreate(name, language, version, targetDir) {
 		return;
 	}
 
+	// Create .gitignore file unless --no-gitignore flag is set
+	if (!noGitignore) {
+		const gitignoreCreated = createGitignore(targetDir, language);
+		if (gitignoreCreated) {
+			console.log(chalk.dim(`   Created .gitignore for ${language}`));
+		}
+	}
+
 	// Get authentication credentials
 	const env = await getCurrentEnv();
 	if (!env || !env.token || !env.session) {
@@ -383,7 +497,26 @@ async function handleCodeTypeCreate(name, language, version, targetDir) {
 /**
  * Handle git type serverless creation - creates serverless on server and clones the repo
  */
-async function handleGitTypeCreate(name, language, version, targetDir) {
+async function handleGitTypeCreate(
+	name,
+	language,
+	version,
+	targetDir,
+	noGitignore = false
+) {
+	// Check if serverless with this name already exists
+	const existingServerless = await checkServerlessExists(name);
+	if (existingServerless) {
+		displayServerlessExistsMessage(name, existingServerless);
+		// Cleanup the created directory
+		try {
+			fs.rmSync(targetDir, { recursive: true, force: true });
+		} catch {
+			// Ignore cleanup errors
+		}
+		return;
+	}
+
 	console.log(chalk.cyan("\n📁 Creating git-based serverless project..."));
 	console.log(chalk.dim(`   Type: git`));
 	console.log(chalk.dim(`   Language: ${language}/${version}`));
@@ -523,6 +656,14 @@ serverlessConfig:
 		}
 	}
 
+	// Create .gitignore file unless --no-gitignore flag is set
+	if (!noGitignore) {
+		const gitignoreCreated = createGitignore(targetDir, language);
+		if (gitignoreCreated) {
+			console.log(chalk.dim(`   Created .gitignore for ${language}`));
+		}
+	}
+
 	// Display success message
 	console.log("\n" + chalk.bgGreen.black(" ✓ CREATED ") + "\n");
 	console.log(
@@ -608,7 +749,20 @@ serverlessConfig:
 /**
  * Handle container type serverless creation - creates empty folder with boltic.yaml
  */
-async function handleContainerTypeCreate(name, targetDir) {
+async function handleContainerTypeCreate(name, targetDir, noGitignore = false) {
+	// Check if serverless with this name already exists
+	const existingServerless = await checkServerlessExists(name);
+	if (existingServerless) {
+		displayServerlessExistsMessage(name, existingServerless);
+		// Cleanup the created directory
+		try {
+			fs.rmSync(targetDir, { recursive: true, force: true });
+		} catch {
+			// Ignore cleanup errors
+		}
+		return;
+	}
+
 	console.log(
 		chalk.cyan("\n🐳 Creating container-based serverless project...")
 	);
@@ -724,6 +878,14 @@ build:
 		return;
 	}
 
+	// Create .gitignore file unless --no-gitignore flag is set
+	if (!noGitignore) {
+		const gitignoreCreated = createGitignore(targetDir, "container");
+		if (gitignoreCreated) {
+			console.log(chalk.dim(`   Created .gitignore`));
+		}
+	}
+
 	// Display success message for container type
 	console.log("\n" + chalk.bgGreen.black(" ✓ CREATED ") + "\n");
 	console.log(
@@ -768,7 +930,12 @@ async function handlePublish(args = []) {
 
 		// Step 1: Parse CLI arguments
 		const parsedArgs = parsePublishArgs(args);
-		const { directory } = parsedArgs;
+		const { directory, verbose } = parsedArgs;
+
+		// Enable verbose mode if requested
+		if (verbose) {
+			setVerboseMode(true);
+		}
 
 		// Validate directory exists
 		if (!fs.existsSync(directory)) {
@@ -821,10 +988,28 @@ async function handlePublish(args = []) {
 		let code = null;
 		if (runtime === "git") {
 			console.log(
-				chalk.red("\n📄 Git type serverless does not support publish")
+				chalk.yellow(
+					"\n📦 Git-based serverless deploys via git push, not publish."
+				)
+			);
+			console.log(chalk.cyan("\nTo deploy your changes:\n"));
+			console.log(chalk.white("   # Stage your changes"));
+			console.log(chalk.green("   git add .\n"));
+			console.log(chalk.white("   # Commit your changes"));
+			console.log(
+				chalk.green('   git commit -m "Update serverless function"\n')
+			);
+			console.log(chalk.white("   # Push to deploy"));
+			console.log(chalk.green("   git push origin main\n"));
+			console.log(
+				chalk.dim(
+					"The serverless will automatically build and deploy after push."
+				)
 			);
 			console.log(
-				chalk.yellow("Please publish using git push origin main")
+				chalk.dim(
+					`Monitor status with: boltic serverless status --name ${appName} --follow\n`
+				)
 			);
 			return;
 		}
@@ -1105,7 +1290,6 @@ async function handleTest(args = []) {
 		// Install Python dependencies using virtual environment
 		if (language === "python") {
 			const venvPath = path.join(directory, ".venv");
-			const venvPython = path.join(venvPath, "bin", "python3");
 			const venvPip = path.join(venvPath, "bin", "pip3");
 
 			// Create virtual environment if it doesn't exist
@@ -1379,27 +1563,32 @@ async function handlePull(args) {
 	try {
 		// Parse command line arguments
 		let currentDir = process.cwd();
-		const pathIndex = args.indexOf("--path");
-
-		if (pathIndex !== -1 && args[pathIndex + 1]) {
-			currentDir = args[pathIndex + 1];
-			// Validate the provided path
-			if (!fs.existsSync(currentDir)) {
-				console.error(
-					chalk.red(
-						`Error: The specified path does not exist: ${currentDir}`
-					)
-				);
-				return;
+		let serverlessName = null;
+
+		for (let i = 0; i < args.length; i++) {
+			const arg = args[i];
+			const nextArg = args[i + 1];
+
+			if (arg === "--path" && nextArg) {
+				currentDir = nextArg;
+				i++;
+			} else if ((arg === "--name" || arg === "-n") && nextArg) {
+				serverlessName = nextArg;
+				i++;
 			}
 		}
-		const { apiUrl, token, accountId, session } = await getCurrentEnv();
 
-		console.log(
-			chalk.green(
-				"Please select the serverless to pull from the list below:"
-			)
-		);
+		// Validate the provided path
+		if (currentDir !== process.cwd() && !fs.existsSync(currentDir)) {
+			console.error(
+				chalk.red(
+					`Error: The specified path does not exist: ${currentDir}`
+				)
+			);
+			return;
+		}
+
+		const { apiUrl, token, accountId, session } = await getCurrentEnv();
 
 		const allServerless = await listAllServerless(
 			apiUrl,
@@ -1413,42 +1602,85 @@ async function handlePull(args) {
 					"\n❌ Failed to fetch serverless: Invalid response format"
 				)
 			);
+			return;
 		}
 		if (allServerless.length === 0) {
 			console.error(chalk.red("\n❌ No serverless found."));
 			return;
 		}
-		// Let user select an integration
-		const choices =
-			allServerless.map((serverless) => {
-				const runtime = serverless.Config?.Runtime || "code";
-				const typeIcon =
-					runtime === "git"
-						? "📦"
-						: runtime === "container"
-							? "🐳"
-							: "📝";
-				const language = serverless.Config?.CodeOpts?.Language;
-				return {
-					name: `${serverless.Config.Name}: ${typeIcon} ${runtime} | Status - ${serverless.Status}${language ? ` | language: ${language}` : ""}`,
-					value: serverless,
-				};
-			}) || [];
 
-		const selectedServerless = await search({
-			message: "Search and select an serverless to edit:",
-			source: async (term) => {
-				if (!term) return choices;
-				return choices?.filter((choice) =>
-					choice.name.toLowerCase().includes(term.toLowerCase())
+		let selectedServerless;
+
+		// If name is provided, find exact match
+		if (serverlessName) {
+			selectedServerless = allServerless.find(
+				(s) =>
+					s.Config?.Name?.toLowerCase() ===
+					serverlessName.toLowerCase()
+			);
+
+			if (!selectedServerless) {
+				console.error(
+					chalk.red(`\n❌ Serverless "${serverlessName}" not found.`)
 				);
-			},
-		});
+				console.log(chalk.yellow("\nAvailable serverless functions:"));
+				allServerless.slice(0, 5).forEach((s) => {
+					console.log(chalk.dim(`   - ${s.Config?.Name}`));
+				});
+				if (allServerless.length > 5) {
+					console.log(
+						chalk.dim(`   ... and ${allServerless.length - 5} more`)
+					);
+				}
+				console.log(
+					chalk.yellow("\nRun 'boltic serverless list' to see all.")
+				);
+				return;
+			}
 
-		console.log(
-			chalk.cyan("\nSelected serverless:"),
-			selectedServerless.Config.Name
-		);
+			console.log(
+				chalk.cyan("Selected serverless:"),
+				selectedServerless.Config.Name
+			);
+		} else {
+			// Interactive selection
+			console.log(
+				chalk.green(
+					"Please select the serverless to pull from the list below:"
+				)
+			);
+
+			const choices =
+				allServerless.map((serverless) => {
+					const runtime = serverless.Config?.Runtime || "code";
+					const typeIcon =
+						runtime === "git"
+							? "📦"
+							: runtime === "container"
+								? "🐳"
+								: "📝";
+					const language = serverless.Config?.CodeOpts?.Language;
+					return {
+						name: `${serverless.Config.Name}: ${typeIcon} ${runtime} | Status - ${serverless.Status}${language ? ` | language: ${language}` : ""}`,
+						value: serverless,
+					};
+				}) || [];
+
+			selectedServerless = await search({
+				message: "Search and select an serverless to edit:",
+				source: async (term) => {
+					if (!term) return choices;
+					return choices?.filter((choice) =>
+						choice.name.toLowerCase().includes(term.toLowerCase())
+					);
+				},
+			});
+
+			console.log(
+				chalk.cyan("\nSelected serverless:"),
+				selectedServerless.Config.Name
+			);
+		}
 		const pulledServerless = await pullServerless(
 			apiUrl,
 			token,
@@ -1466,12 +1698,9 @@ async function handlePull(args) {
 		}
 		// console.log("selectes serverless : ",pulledServerless)
 
-		// Get the app name, language and type for the folder name
+		// Get the app name and type for the folder name
 		const appName =
 			pulledServerless?.Config?.Name || selectedServerless.Config?.Name;
-		const language =
-			pulledServerless?.Config?.CodeOpts?.Language?.split("/")[0] ||
-			"nodejs";
 		const serverlessType = pulledServerless?.Config?.Runtime || "code";
 
 		// Create folder name similar to create command
@@ -1538,133 +1767,185 @@ async function handlePull(args) {
 function showHelp() {
 	console.log(chalk.cyan("\nServerless Commands:\n"));
 	Object.entries(commands).forEach(([cmd, details]) => {
-		console.log(chalk.bold(`  ${cmd}`) + ` - ${details.description}`);
+		console.log(chalk.bold(`  ${cmd.padEnd(12)}`) + details.description);
 	});
 
-	console.log(chalk.cyan("\nCreate Command Options:\n"));
+	console.log(chalk.cyan("\nGlobal Options:\n"));
+	console.log(
+		chalk.bold("  --help, -h".padEnd(20)) + "Show help for a command"
+	);
+
+	console.log(chalk.cyan("\nCreate Options:\n"));
 	console.log(
-		chalk.bold("  --type, -t") +
-			chalk.dim("           ") +
-			"Serverless type: blueprint, git, or container (prompts if not provided)"
+		chalk.bold("  --type, -t".padEnd(20)) +
+			"Serverless type: blueprint, git, or container"
 	);
 	console.log(
-		chalk.bold("  --name, -n") +
-			chalk.dim("           ") +
-			"Name of the serverless function (required, prompts if not provided)"
+		chalk.bold("  --name, -n".padEnd(20)) +
+			"Name of the serverless function"
 	);
 	console.log(
-		chalk.bold("  --language, -l") +
-			chalk.dim("       ") +
-			"Programming language: nodejs, python, golang, java (prompts if not provided)"
+		chalk.bold("  --language, -l".padEnd(20)) +
+			"Programming language: nodejs, python, golang, java"
 	);
 	console.log(
-		chalk.bold("  --directory, -d") +
-			chalk.dim("      ") +
-			"Directory where to create the project (default: current directory)"
+		chalk.bold("  --directory, -d".padEnd(20)) +
+			"Directory for the project (default: current)"
 	);
 
-	console.log(chalk.cyan("\nTest Command Options:\n"));
+	console.log(chalk.cyan("\nTest Options:\n"));
 	console.log(
-		chalk.bold("  --port, -p") +
-			chalk.dim("           ") +
+		chalk.bold("  --port, -p".padEnd(20)) +
 			"Port to run the server on (default: 8080)"
 	);
 	console.log(
-		chalk.bold("  --language, -l") +
-			chalk.dim("       ") +
-			"Language (nodejs, python, golang, java) - auto-detected if not specified"
+		chalk.bold("  --language, -l".padEnd(20)) +
+			"Language (auto-detected if not specified)"
 	);
 	console.log(
-		chalk.bold("  --directory, -d") +
-			chalk.dim("      ") +
-			"Base directory of the project (default: current directory)"
+		chalk.bold("  --directory, -d".padEnd(20)) +
+			"Base directory of the project"
 	);
 
-	console.log(chalk.cyan("\nPublish Command Options:\n"));
+	console.log(chalk.cyan("\nPublish Options:\n"));
 	console.log(
-		chalk.bold("  --directory, -d") +
-			chalk.dim("      ") +
-			"Directory of the serverless project (default: current directory)"
+		chalk.bold("  --directory, -d".padEnd(20)) +
+			"Directory of the serverless project"
 	);
 
-	console.log(chalk.cyan("\nStatus Command Options:\n"));
+	console.log(chalk.cyan("\nStatus Options:\n"));
 	console.log(
-		chalk.bold("  --name, -n") +
-			chalk.dim("           ") +
-			"Name of the serverless function (prompts if not provided)"
+		chalk.bold("  --name, -n".padEnd(20)) +
+			"Name of the serverless function"
+	);
+	console.log(
+		chalk.bold("  --follow, -f".padEnd(20)) +
+			"Poll until status is running, failed, or degraded"
 	);
 
-	console.log(chalk.cyan("\nCreate Examples:\n"));
+	console.log(chalk.cyan("\nBuilds Options:\n"));
 	console.log(
-		chalk.dim(
-			"  # Interactive mode (will prompt for type, name, and language)"
-		)
+		chalk.bold("  --name, -n".padEnd(20)) +
+			"Name of the serverless function"
 	);
-	console.log("  boltic serverless create\n");
-	console.log(chalk.dim("  # Create blueprint serverless"));
+
+	console.log(chalk.cyan("\nLogs Options:\n"));
 	console.log(
-		"  boltic serverless create --type blueprint --name my-api --language nodejs\n"
+		chalk.bold("  --name, -n".padEnd(20)) +
+			"Name of the serverless function"
 	);
 	console.log(
-		chalk.dim(
-			"  # Create git-based serverless (add your code, then publish)"
-		)
+		chalk.bold("  --follow, -f".padEnd(20)) + "Follow logs in real-time"
+	);
+	console.log(
+		chalk.bold("  --lines, -l".padEnd(20)) +
+			"Number of lines to show (default: 100)"
 	);
+
+	console.log(chalk.cyan("\nBuild Logs Options:\n"));
 	console.log(
-		"  boltic serverless create --type git --name my-git-func --language python\n"
+		chalk.bold("  --name, -n".padEnd(20)) +
+			"Name of the serverless function"
 	);
-	console.log(chalk.dim("  # Create container-based serverless"));
 	console.log(
-		"  boltic serverless create --type container --name my-container --language golang\n"
+		chalk.bold("  --build, -b".padEnd(20)) +
+			"Build ID (prompts if not provided)"
 	);
-	console.log(chalk.dim("  # With custom directory"));
+
+	console.log(chalk.cyan("\nExamples:\n"));
+
+	console.log(chalk.dim("  # Create a blueprint serverless"));
 	console.log(
-		"  boltic serverless create --type blueprint --name my-function --language python --directory ./projects\n"
+		"  boltic serverless create -t blueprint -n my-api -l nodejs\n"
 	);
 
-	console.log(chalk.cyan("\nTest Examples:\n"));
-	console.log(chalk.dim("  # Basic usage - auto-detect everything"));
-	console.log("  boltic serverless test\n");
-	console.log(chalk.dim("  # Specify port"));
-	console.log("  boltic serverless test --port 3000\n");
+	console.log(chalk.dim("  # Test locally on port 3000"));
+	console.log("  boltic serverless test -p 3000\n");
 
-	console.log(chalk.cyan("\nPublish Examples:\n"));
 	console.log(chalk.dim("  # Publish from current directory"));
 	console.log("  boltic serverless publish\n");
-	console.log(chalk.dim("  # Publish from specific directory"));
-	console.log("  boltic serverless publish -d ./my-function\n");
 
-	console.log(chalk.cyan("\nList Examples:\n"));
 	console.log(chalk.dim("  # List all serverless functions"));
 	console.log("  boltic serverless list\n");
 
-	console.log(chalk.cyan("\nStatus Examples:\n"));
-	console.log(chalk.dim("  # Get status by name"));
-	console.log("  boltic serverless status -n my-function\n");
-	console.log(chalk.dim("  # Interactive mode (will prompt for name)"));
-	console.log("  boltic serverless status\n");
+	console.log(chalk.dim("  # Check status with polling"));
+	console.log("  boltic serverless status -n my-function --follow\n");
+
+	console.log(chalk.dim("  # View builds for a serverless"));
+	console.log("  boltic serverless builds -n my-function\n");
+
+	console.log(chalk.dim("  # View runtime logs"));
+	console.log("  boltic serverless logs -n my-function -f\n");
+
+	console.log(chalk.dim("  # View build logs"));
+	console.log("  boltic serverless build logs -n my-function\n");
 }
 
 // Execute the serverless command
 const execute = async (args) => {
-	const subCommand = args[0];
-
-	if (!subCommand) {
+	let subCommand = args[0];
+	let argsToPass = args.slice(1);
+
+	// Handle help flags
+	if (
+		!subCommand ||
+		subCommand === "--help" ||
+		subCommand === "-h" ||
+		args.includes("--help") ||
+		args.includes("-h")
+	) {
 		showHelp();
 		return;
 	}
 
+	// Handle two-word commands like "build logs"
+	if (subCommand === "build" && args[1] === "logs") {
+		subCommand = "build logs";
+		argsToPass = args.slice(2);
+	}
+
 	if (!commands[subCommand]) {
-		console.log(chalk.red("Unknown or missing serverless sub-command.\n"));
+		console.log(chalk.red(`Unknown serverless command: "${subCommand}"\n`));
 		showHelp();
 		return;
 	}
 
 	const commandObj = commands[subCommand];
-	await commandObj.action(args.slice(1));
+	await commandObj.action(argsToPass);
 };
 
-async function handleList(args = []) {
+/**
+ * Get the URL for a serverless function
+ */
+function getServerlessUrl(serverless) {
+	const appDomain = serverless.AppDomain?.[0];
+	if (appDomain) {
+		return `https://${appDomain.DomainName}.${appDomain.BaseUrl || "serverless.boltic.app"}`;
+	}
+	return null;
+}
+
+/**
+ * Get status color for display
+ */
+function getStatusColor(status) {
+	switch (status) {
+		case "running":
+			return chalk.green;
+		case "draft":
+		case "building":
+		case "pending":
+			return chalk.yellow;
+		case "stopped":
+		case "failed":
+		case "degraded":
+			return chalk.red;
+		default:
+			return chalk.gray;
+	}
+}
+
+async function handleList(_args = []) {
 	try {
 		const { apiUrl, token, accountId, session } = await getCurrentEnv();
 
@@ -1709,9 +1990,10 @@ async function handleList(args = []) {
 						: "📝";
 			const language = serverless.Config?.CodeOpts?.Language;
 			const status = serverless.Status;
+			const url = getServerlessUrl(serverless);
 
 			return {
-				name: `${serverless.Config.Name}: ${typeIcon} ${runtime} | Status - ${status}${language ? ` | ${language}` : ""} | ID: ${serverless.ID.substring(0, 8)}...`,
+				name: `${serverless.Config.Name}: ${typeIcon} ${runtime} | ${status}${language ? ` | ${language}` : ""}${url ? ` | ${url}` : ""}`,
 				value: serverless,
 			};
 		});
@@ -1729,44 +2011,7 @@ async function handleList(args = []) {
 
 		// Show details of selected serverless
 		if (selected) {
-			const runtime = selected.Config?.Runtime || "code";
-			const typeIcon =
-				runtime === "git"
-					? "📦"
-					: runtime === "container"
-						? "🐳"
-						: "📝";
-
-			console.log("\n" + chalk.cyan("━".repeat(60)));
-			console.log(chalk.bold("\n📌 Selected Serverless Details:\n"));
-			console.log(
-				chalk.cyan("   Name: ") + chalk.white(selected.Config.Name)
-			);
-			console.log(chalk.cyan("   ID: ") + chalk.white(selected.ID));
-			console.log(
-				chalk.cyan("   Type: ") + chalk.white(`${typeIcon} ${runtime}`)
-			);
-			console.log(
-				chalk.cyan("   Status: ") + chalk.white(selected.Status)
-			);
-			if (selected.Config?.CodeOpts?.Language) {
-				console.log(
-					chalk.cyan("   Language: ") +
-						chalk.white(selected.Config.CodeOpts.Language)
-				);
-			}
-			if (selected.Config?.ContainerOpts?.Image) {
-				console.log(
-					chalk.cyan("   Image: ") +
-						chalk.white(selected.Config.ContainerOpts.Image)
-				);
-			}
-			console.log(chalk.cyan("━".repeat(60)));
-			console.log(
-				chalk.dim(
-					"\nUse 'boltic serverless pull' to pull this serverless locally."
-				)
-			);
+			displayServerlessDetails(selected);
 		}
 	} catch (error) {
 		if (
@@ -1784,142 +2029,1000 @@ async function handleList(args = []) {
 }
 
 /**
- * Handle the status command - show status of a serverless function
+ * Display detailed information about a serverless function
  */
-async function handleStatus(args = []) {
-	try {
-		// Parse name from args
-		let name = null;
-		const nameIndex = args.indexOf("--name");
-		const shortNameIndex = args.indexOf("-n");
-
-		if (nameIndex !== -1 && args[nameIndex + 1]) {
-			name = args[nameIndex + 1];
-		} else if (shortNameIndex !== -1 && args[shortNameIndex + 1]) {
-			name = args[shortNameIndex + 1];
-		}
-
-		// If name not provided, prompt for it
-		if (!name) {
-			name = await input({
-				message: "Enter serverless name:",
-				validate: (value) => {
-					if (!value || value.trim() === "") {
-						return "Serverless name is required";
-					}
-					return true;
-				},
-			});
-		}
-
-		const { apiUrl, token, accountId, session } = await getCurrentEnv();
+function displayServerlessDetails(serverless) {
+	const runtime = serverless.Config?.Runtime || "code";
+	const typeIcon =
+		runtime === "git" ? "📦" : runtime === "container" ? "🐳" : "📝";
+	const status = serverless.Status;
+	const statusColor = getStatusColor(status);
+	const url = getServerlessUrl(serverless);
+
+	console.log("\n" + chalk.cyan("━".repeat(60)));
+	console.log(chalk.bold("\n📊 Serverless Details\n"));
+	console.log(chalk.cyan("   Name: ") + chalk.white(serverless.Config.Name));
+	console.log(chalk.cyan("   ID: ") + chalk.white(serverless.ID));
+	console.log(
+		chalk.cyan("   Type: ") + chalk.white(`${typeIcon} ${runtime}`)
+	);
+	console.log(chalk.cyan("   Status: ") + statusColor(status));
 
-		console.log(chalk.cyan(`\n🔍 Fetching status for "${name}"...\n`));
+	if (url) {
+		console.log(chalk.cyan("   URL: ") + chalk.white.bold(url));
+	}
 
-		// Get serverless by name using query parameter
-		const result = await listAllServerless(
-			apiUrl,
-			token,
-			accountId,
-			session,
-			name // Pass name as query parameter
+	if (serverless.Config?.CodeOpts?.Language) {
+		console.log(
+			chalk.cyan("   Language: ") +
+				chalk.white(serverless.Config.CodeOpts.Language)
 		);
-
-		if (!result || !Array.isArray(result)) {
-			console.error(
-				chalk.red(
-					"\n❌ Failed to fetch serverless: Invalid response format"
+	}
+	if (serverless.Config?.ContainerOpts?.Image) {
+		console.log(
+			chalk.cyan("   Image: ") +
+				chalk.white(serverless.Config.ContainerOpts.Image)
+		);
+	}
+	if (serverless.Config?.Resources) {
+		console.log(
+			chalk.cyan("   Resources: ") +
+				chalk.white(
+					`CPU: ${serverless.Config.Resources.CPU}, Memory: ${serverless.Config.Resources.MemoryMB}MB`
 				)
-			);
-			return;
-		}
-
-		// Get first element (name is unique)
-		const serverless = result[0];
-
-		if (!serverless) {
-			console.error(chalk.red(`\n❌ Serverless "${name}" not found.`));
-			console.log(
-				chalk.yellow(
-					"\nUse 'boltic serverless list' to see all serverless functions."
+		);
+	}
+	if (serverless.Config?.Scaling) {
+		console.log(
+			chalk.cyan("   Scaling: ") +
+				chalk.white(
+					`Min: ${serverless.Config.Scaling.Min}, Max: ${serverless.Config.Scaling.Max}`
 				)
+		);
+	}
+	if (serverless.RegionID) {
+		console.log(
+			chalk.cyan("   Region: ") + chalk.white(serverless.RegionID)
+		);
+	}
+	if (serverless.CreatedAt) {
+		console.log(
+			chalk.cyan("   Created: ") +
+				chalk.white(new Date(serverless.CreatedAt).toLocaleString())
+		);
+	}
+	if (serverless.UpdatedAt) {
+		console.log(
+			chalk.cyan("   Updated: ") +
+				chalk.white(new Date(serverless.UpdatedAt).toLocaleString())
+		);
+	}
+
+	console.log();
+	console.log(chalk.cyan("━".repeat(60)));
+	console.log(
+		chalk.dim(
+			"\nTip: Use 'boltic serverless status -n <name> --follow' to poll for status changes."
+		)
+	);
+}
+
+/**
+ * Parse status command arguments
+ */
+function parseStatusArgs(args) {
+	const parsed = {
+		name: null,
+		watch: false,
+		verbose: false,
+		timeout: -1, // -1 means infinite
+	};
+
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		const nextArg = args[i + 1];
+
+		if ((arg === "--name" || arg === "-n") && nextArg) {
+			parsed.name = nextArg;
+			i++;
+		} else if (
+			arg === "--follow" ||
+			arg === "-f" ||
+			arg === "--watch" ||
+			arg === "-w"
+		) {
+			parsed.watch = true;
+		} else if (arg === "--verbose" || arg === "-v") {
+			parsed.verbose = true;
+		} else if ((arg === "--timeout" || arg === "-t") && nextArg) {
+			parsed.timeout = parseInt(nextArg, 10);
+			i++;
+		} else if (!arg.startsWith("-") && !parsed.name) {
+			// Accept positional argument as name
+			parsed.name = arg;
+		}
+	}
+
+	return parsed;
+}
+
+/**
+ * Handle the status command - show status of a serverless function
+ */
+async function handleStatus(args = []) {
+	try {
+		const parsedArgs = parseStatusArgs(args);
+		let { name, watch, verbose, timeout } = parsedArgs;
+
+		// Enable verbose mode if requested
+		if (verbose) {
+			setVerboseMode(true);
+		}
+
+		const { apiUrl, token, accountId, session } = await getCurrentEnv();
+
+		// If name not provided, show list selector
+		if (!name) {
+			console.log(chalk.cyan("\n📋 Fetching serverless functions...\n"));
+
+			const allServerless = await listAllServerless(
+				apiUrl,
+				token,
+				accountId,
+				session
+			);
+
+			if (!allServerless || !Array.isArray(allServerless)) {
+				console.error(
+					chalk.red(
+						"\n❌ Failed to fetch serverless: Invalid response format"
+					)
+				);
+				return;
+			}
+
+			if (allServerless.length === 0) {
+				console.log(chalk.yellow("No serverless functions found."));
+				return;
+			}
+
+			// Build choices for the list
+			const choices = allServerless.map((serverless) => {
+				const runtime = serverless.Config?.Runtime || "code";
+				const typeIcon =
+					runtime === "git"
+						? "📦"
+						: runtime === "container"
+							? "🐳"
+							: "📝";
+				const status = serverless.Status;
+				const statusColor = getStatusColor(status);
+
+				return {
+					name: `${serverless.Config.Name} | ${typeIcon} ${runtime} | ${statusColor(status)}`,
+					value: serverless,
+				};
+			});
+
+			const selected = await search({
+				message: "Select a serverless function:",
+				source: async (term) => {
+					if (!term) return choices;
+					return choices.filter((choice) =>
+						choice.name.toLowerCase().includes(term.toLowerCase())
+					);
+				},
+			});
+
+			if (!selected) {
+				return;
+			}
+
+			// Display status directly since we have the full object
+			displayServerlessDetails(selected);
+
+			// If watch mode, continue polling
+			if (watch) {
+				name = selected.Config.Name;
+			} else {
+				return;
+			}
+		}
+
+		// If not in watch mode (and name was provided), just fetch and display once
+		if (!watch) {
+			console.log(chalk.cyan(`\n🔍 Fetching status for "${name}"...\n`));
+
+			// First find the serverless by name to get the ID
+			const result = await listAllServerless(
+				apiUrl,
+				token,
+				accountId,
+				session,
+				name
 			);
+
+			if (!result || !Array.isArray(result) || !result[0]) {
+				console.error(
+					chalk.red(`\n❌ Serverless "${name}" not found.`)
+				);
+				console.log(
+					chalk.yellow(
+						"\nUse 'boltic serverless list' to see all serverless functions."
+					)
+				);
+				return;
+			}
+
+			// Use pullServerless to get the full details with accurate status
+			const serverlessId = result[0].ParentID || result[0].ID;
+			const serverless = await pullServerless(
+				apiUrl,
+				token,
+				accountId,
+				session,
+				serverlessId
+			);
+
+			if (!serverless) {
+				console.error(
+					chalk.red("\n❌ Failed to fetch serverless details")
+				);
+				return;
+			}
+
+			displayServerlessDetails(serverless);
+			return;
+		}
+
+		// Watch mode - poll for status changes
+		console.log(chalk.cyan(`\n👁️  Watching status for "${name}"...\n`));
+		const timeoutMsg = timeout > 0 ? ` (timeout: ${timeout}s)` : "";
+		console.log(chalk.dim(`Press Ctrl+C to stop watching.${timeoutMsg}\n`));
+
+		// First, get the serverless ID
+		const initialResult = await listAllServerless(
+			apiUrl,
+			token,
+			accountId,
+			session,
+			name
+		);
+
+		if (
+			!initialResult ||
+			!Array.isArray(initialResult) ||
+			!initialResult[0]
+		) {
+			console.error(chalk.red(`\n❌ Serverless "${name}" not found.`));
 			return;
 		}
 
-		// Display status
+		const serverlessId = initialResult[0].ParentID || initialResult[0].ID;
+		const terminalStates = ["running", "failed", "degraded", "suspended"];
+		let lastStatus = null;
+		let iteration = 0;
+		const startTime = Date.now();
+
+		while (true) {
+			iteration++;
+
+			// Check timeout (-1 means infinite)
+			if (timeout > 0) {
+				const elapsed = Math.floor((Date.now() - startTime) / 1000);
+				if (elapsed >= timeout) {
+					console.log(
+						chalk.yellow(
+							`\n\n⏱️  Timeout reached after ${timeout} seconds.`
+						)
+					);
+					return;
+				}
+			}
+
+			// Use pullServerless for accurate status
+			const serverless = await pullServerless(
+				apiUrl,
+				token,
+				accountId,
+				session,
+				serverlessId
+			);
+
+			if (!serverless) {
+				console.error(
+					chalk.red(`\n❌ Failed to fetch serverless status.`)
+				);
+				return;
+			}
+			const status = serverless.Status;
+			const statusColor = getStatusColor(status);
+			const url = getServerlessUrl(serverless);
+
+			// Show status update
+			const timestamp = new Date().toLocaleTimeString();
+			if (status !== lastStatus) {
+				console.log(
+					chalk.dim(`[${timestamp}]`) +
+						` Status: ${statusColor(status)}` +
+						(url ? chalk.dim(` | ${url}`) : "")
+				);
+				lastStatus = status;
+			} else if (iteration % 3 === 0) {
+				// Show a dot every 3 iterations to indicate it's still polling
+				process.stdout.write(chalk.dim("."));
+			}
+
+			// Check if we've reached a terminal state
+			if (terminalStates.includes(status)) {
+				console.log();
+				displayServerlessDetails(serverless);
+				console.log(
+					chalk.green(`\n✓ Reached terminal state: ${status}`)
+				);
+				return;
+			}
+
+			// Wait before next poll
+			await new Promise((resolve) => setTimeout(resolve, 5000));
+		}
+	} catch (error) {
+		if (
+			error.message &&
+			error.message.includes("User force closed the prompt")
+		) {
+			console.log(chalk.yellow("\n⚠️ Operation cancelled by user"));
+			return;
+		}
+		console.error(
+			chalk.red("\n❌ An error occurred:"),
+			error.message || "Unknown error"
+		);
+	}
+}
+
+/**
+ * Helper to select a serverless function interactively
+ */
+async function selectServerless(
+	apiUrl,
+	token,
+	accountId,
+	session,
+	message = "Select a serverless function:"
+) {
+	const allServerless = await listAllServerless(
+		apiUrl,
+		token,
+		accountId,
+		session
+	);
+
+	if (!allServerless || !Array.isArray(allServerless)) {
+		throw new Error("Failed to fetch serverless: Invalid response format");
+	}
+
+	if (allServerless.length === 0) {
+		console.log(chalk.yellow("No serverless functions found."));
+		return null;
+	}
+
+	const choices = allServerless.map((serverless) => {
 		const runtime = serverless.Config?.Runtime || "code";
 		const typeIcon =
 			runtime === "git" ? "📦" : runtime === "container" ? "🐳" : "📝";
 		const status = serverless.Status;
-		const statusColor =
-			status === "running"
-				? chalk.green
-				: status === "draft"
-					? chalk.yellow
-					: status === "stopped"
-						? chalk.red
-						: chalk.gray;
 
-		console.log(chalk.cyan("━".repeat(60)));
-		console.log(chalk.bold("\n📊 Serverless Status\n"));
+		return {
+			name: `${serverless.Config.Name} | ${typeIcon} ${runtime} | ${status}`,
+			value: serverless,
+		};
+	});
+
+	return await search({
+		message,
+		source: async (term) => {
+			if (!term) return choices;
+			return choices.filter((choice) =>
+				choice.name.toLowerCase().includes(term.toLowerCase())
+			);
+		},
+	});
+}
+
+/**
+ * Handle the builds command - list builds for a serverless function
+ */
+async function handleBuilds(args = []) {
+	try {
+		// Parse name from args (supports --name, -n, or positional)
+		let name = null;
+		for (let i = 0; i < args.length; i++) {
+			const arg = args[i];
+			if ((arg === "--name" || arg === "-n") && args[i + 1]) {
+				name = args[i + 1];
+				break;
+			} else if (!arg.startsWith("-") && !name) {
+				name = arg;
+			}
+		}
+
+		const { apiUrl, token, accountId, session } = await getCurrentEnv();
+
+		let serverless;
+
+		// If name not provided, show selector
+		if (!name) {
+			console.log(chalk.cyan("\n📋 Select a serverless function...\n"));
+			serverless = await selectServerless(
+				apiUrl,
+				token,
+				accountId,
+				session,
+				"Select serverless to view builds:"
+			);
+
+			if (!serverless) {
+				return;
+			}
+		} else {
+			// Fetch by name
+			const result = await listAllServerless(
+				apiUrl,
+				token,
+				accountId,
+				session,
+				name
+			);
+
+			if (!result || !Array.isArray(result) || !result[0]) {
+				console.error(
+					chalk.red(`\n❌ Serverless "${name}" not found.`)
+				);
+				return;
+			}
+			serverless = result[0];
+		}
+
+		// Check if serverless is container type - builds are not available
+		const runtime = serverless.Config?.Runtime || "code";
+		if (runtime === "container") {
+			console.log(
+				chalk.yellow(
+					`\n⚠️  Builds are not available for container-type serverless functions.`
+				)
+			);
+			console.log(
+				chalk.dim(
+					`   Container images are built externally and pulled directly.`
+				)
+			);
+			console.log(
+				chalk.dim(
+					`\n   To view runtime logs, use: boltic serverless logs ${serverless.Config.Name}`
+				)
+			);
+			return;
+		}
+
 		console.log(
-			chalk.cyan("   Name: ") + chalk.white(serverless.Config.Name)
+			chalk.cyan(
+				`\n🔨 Fetching builds for "${serverless.Config.Name}"...\n`
+			)
 		);
-		console.log(chalk.cyan("   ID: ") + chalk.white(serverless.ID));
+
+		const buildsData = await getServerlessBuilds(
+			apiUrl,
+			token,
+			accountId,
+			session,
+			serverless.ID
+		);
+
+		if (!buildsData || !buildsData.data || buildsData.data.length === 0) {
+			console.log(chalk.yellow("No builds found for this serverless."));
+			return;
+		}
+
+		const builds = buildsData.data;
+
+		console.log(chalk.green(`Found ${builds.length} build(s):\n`));
+		console.log(chalk.cyan("━".repeat(100)));
 		console.log(
-			chalk.cyan("   Type: ") + chalk.white(`${typeIcon} ${runtime}`)
+			chalk.bold("  #  ") +
+				chalk.bold("Status".padEnd(12)) +
+				chalk.bold("Version".padEnd(10)) +
+				chalk.bold("Created".padEnd(22)) +
+				chalk.bold("Build ID")
 		);
-		console.log(chalk.cyan("   Status: ") + statusColor(status));
+		console.log(chalk.cyan("━".repeat(100)));
+
+		builds.forEach((build, index) => {
+			const status =
+				build.StatusHistory?.slice(-1)[0]?.Status ||
+				build.Status ||
+				"unknown";
+			const statusColor = getStatusColor(status);
+			const createdAt = build.CreatedAt
+				? new Date(build.CreatedAt).toLocaleString()
+				: "N/A";
+			const version = build.Version || "N/A";
 
-		if (serverless.Config?.CodeOpts?.Language) {
 			console.log(
-				chalk.cyan("   Language: ") +
-					chalk.white(serverless.Config.CodeOpts.Language)
+				chalk.dim(`  ${String(index + 1).padStart(2)} `) +
+					statusColor(status.padEnd(12)) +
+					`v${String(version).padEnd(9)}` +
+					createdAt.padEnd(22) +
+					build.ID
 			);
+
+			// Show status history for recent builds (first 3)
+			if (
+				index < 3 &&
+				build.StatusHistory &&
+				build.StatusHistory.length > 1
+			) {
+				const history = build.StatusHistory.map((h) => {
+					const ts = h.Timestamp
+						? new Date(h.Timestamp).toLocaleTimeString()
+						: "";
+					return `${h.Status}${ts ? ` (${ts})` : ""}`;
+				}).join(" → ");
+				console.log(chalk.dim(`      └─ ${history}`));
+			}
+		});
+
+		console.log(chalk.cyan("━".repeat(100)));
+		console.log(
+			chalk.dim(
+				"\nTip: Use 'boltic serverless build logs -n <name>' to view logs for a build."
+			)
+		);
+	} catch (error) {
+		if (
+			error.message &&
+			error.message.includes("User force closed the prompt")
+		) {
+			console.log(chalk.yellow("\n⚠️ Operation cancelled by user"));
+			return;
 		}
-		if (serverless.Config?.ContainerOpts?.Image) {
-			console.log(
-				chalk.cyan("   Image: ") +
-					chalk.white(serverless.Config.ContainerOpts.Image)
+		console.error(
+			chalk.red("\n❌ An error occurred:"),
+			error.message || "Unknown error"
+		);
+	}
+}
+
+/**
+ * Handle the logs command - show logs for a serverless function
+ */
+async function handleLogs(args = []) {
+	try {
+		// Parse args (supports --name, -n, or positional)
+		let name = null;
+		let follow = false;
+		let lines = 100;
+
+		for (let i = 0; i < args.length; i++) {
+			const arg = args[i];
+			const nextArg = args[i + 1];
+
+			if ((arg === "--name" || arg === "-n") && nextArg) {
+				name = nextArg;
+				i++;
+			} else if (arg === "--follow" || arg === "-f") {
+				follow = true;
+			} else if ((arg === "--lines" || arg === "-l") && nextArg) {
+				lines = parseInt(nextArg, 10) || 100;
+				i++;
+			} else if (!arg.startsWith("-") && !name) {
+				// Accept positional argument as name
+				name = arg;
+			}
+		}
+
+		const { apiUrl, token, accountId, session } = await getCurrentEnv();
+
+		let serverless;
+
+		// If name not provided, show selector
+		if (!name) {
+			console.log(chalk.cyan("\n📋 Select a serverless function...\n"));
+			serverless = await selectServerless(
+				apiUrl,
+				token,
+				accountId,
+				session,
+				"Select serverless to view logs:"
+			);
+
+			if (!serverless) {
+				return;
+			}
+		} else {
+			// Fetch by name
+			const result = await listAllServerless(
+				apiUrl,
+				token,
+				accountId,
+				session,
+				name
 			);
+
+			if (!result || !Array.isArray(result) || !result[0]) {
+				console.error(
+					chalk.red(`\n❌ Serverless "${name}" not found.`)
+				);
+				return;
+			}
+			serverless = result[0];
 		}
-		if (serverless.Config?.Resources) {
-			console.log(
-				chalk.cyan("   Resources: ") +
-					chalk.white(
-						`CPU: ${serverless.Config.Resources.CPU}, Memory: ${serverless.Config.Resources.MemoryMB}MB`
-					)
+
+		console.log(
+			chalk.cyan(
+				`\n📜 Fetching logs for "${serverless.Config.Name}"...\n`
+			)
+		);
+
+		if (follow) {
+			console.log(chalk.dim("Following logs... Press Ctrl+C to stop.\n"));
+		}
+
+		// Track seen log IDs to avoid duplicates in follow mode
+		const seenLogIds = new Set();
+
+		const fetchAndDisplayLogs = async (afterTimestamp = null) => {
+			const now = Math.floor(Date.now() / 1000);
+			const logsData = await getServerlessLogs(
+				apiUrl,
+				token,
+				accountId,
+				session,
+				serverless.ID,
+				{
+					limit: lines,
+					// For follow mode: fetch logs AFTER the last seen timestamp
+					// For initial fetch: get last 24 hours
+					timestampStart: afterTimestamp || now - 24 * 60 * 60,
+					timestampEnd: now,
+				}
 			);
+
+			if (!logsData || !logsData.data || logsData.data.length === 0) {
+				if (!follow && !afterTimestamp) {
+					console.log(
+						chalk.yellow("No logs found for this serverless.")
+					);
+				}
+				return afterTimestamp;
+			}
+
+			const logs = logsData.data;
+			let latestTimestamp = afterTimestamp;
+
+			// Sort logs by timestamp ascending for proper display order
+			const sortedLogs = [...logs].sort(
+				(a, b) => (a.Timestamp || 0) - (b.Timestamp || 0)
+			);
+
+			sortedLogs.forEach((log) => {
+				// Create a unique ID for deduplication
+				const logId = `${log.Timestamp}-${log.Log}`;
+				if (seenLogIds.has(logId)) {
+					return; // Skip duplicate
+				}
+				seenLogIds.add(logId);
+
+				// Timestamp is unix epoch in seconds
+				const timestamp = log.Timestamp
+					? new Date(log.Timestamp * 1000).toLocaleTimeString()
+					: "";
+				const severity = log.Severity || "INFO";
+				const severityColor =
+					severity === "ERROR"
+						? chalk.red
+						: severity === "WARNING" || severity === "WARN"
+							? chalk.yellow
+							: severity === "DEBUG"
+								? chalk.blue
+								: chalk.gray;
+
+				// Parse the Log field which may contain JSON
+				let message = "";
+				if (log.Log) {
+					try {
+						const parsed = JSON.parse(log.Log);
+						message = parsed.msg || parsed.message || log.Log;
+					} catch {
+						// Not JSON, use as-is
+						message = log.Log;
+					}
+				}
+
+				console.log(
+					chalk.dim(`[${timestamp}]`) +
+						` ${severityColor(severity.padEnd(7))} ${message}`
+				);
+
+				if (
+					log.Timestamp &&
+					(!latestTimestamp || log.Timestamp > latestTimestamp)
+				) {
+					latestTimestamp = log.Timestamp;
+				}
+			});
+
+			return latestTimestamp;
+		};
+
+		let lastTimestamp = await fetchAndDisplayLogs();
+
+		if (follow) {
+			// Poll for new logs every 2 seconds
+			while (true) {
+				await new Promise((resolve) => setTimeout(resolve, 2000));
+				lastTimestamp = await fetchAndDisplayLogs(lastTimestamp);
+			}
 		}
-		if (serverless.Config?.Scaling) {
-			console.log(
-				chalk.cyan("   Scaling: ") +
-					chalk.white(
-						`Min: ${serverless.Config.Scaling.Min}, Max: ${serverless.Config.Scaling.Max}`
-					)
+	} catch (error) {
+		if (
+			error.message &&
+			error.message.includes("User force closed the prompt")
+		) {
+			console.log(chalk.yellow("\n⚠️ Operation cancelled by user"));
+			return;
+		}
+		console.error(
+			chalk.red("\n❌ An error occurred:"),
+			error.message || "Unknown error"
+		);
+	}
+}
+
+/**
+ * Handle the "build logs" command - show logs for a specific build
+ */
+async function handleBuildLogs(args = []) {
+	try {
+		// Parse args (supports --name, -n, --build, -b, --follow, -f)
+		let name = null;
+		let buildId = null;
+		let follow = false;
+
+		for (let i = 0; i < args.length; i++) {
+			const arg = args[i];
+			const nextArg = args[i + 1];
+
+			if ((arg === "--name" || arg === "-n") && nextArg) {
+				name = nextArg;
+				i++;
+			} else if ((arg === "--build" || arg === "-b") && nextArg) {
+				buildId = nextArg;
+				i++;
+			} else if (arg === "--follow" || arg === "-f") {
+				follow = true;
+			} else if (!arg.startsWith("-") && !name) {
+				// Accept positional argument as name
+				name = arg;
+			}
+		}
+
+		const { apiUrl, token, accountId, session } = await getCurrentEnv();
+
+		let serverless;
+
+		// If name not provided, show selector
+		if (!name) {
+			console.log(chalk.cyan("\n📋 Select a serverless function...\n"));
+			serverless = await selectServerless(
+				apiUrl,
+				token,
+				accountId,
+				session,
+				"Select serverless to view build logs:"
 			);
+
+			if (!serverless) {
+				return;
+			}
+		} else {
+			// Fetch by name
+			const result = await listAllServerless(
+				apiUrl,
+				token,
+				accountId,
+				session,
+				name
+			);
+
+			if (!result || !Array.isArray(result) || !result[0]) {
+				console.error(
+					chalk.red(`\n❌ Serverless "${name}" not found.`)
+				);
+				return;
+			}
+			serverless = result[0];
 		}
-		if (serverless.RegionID) {
+
+		// Check if serverless is container type - build logs are not available
+		const runtime = serverless.Config?.Runtime || "code";
+		if (runtime === "container") {
+			console.log(
+				chalk.yellow(
+					`\n⚠️  Build logs are not available for container-type serverless functions.`
+				)
+			);
 			console.log(
-				chalk.cyan("   Region: ") + chalk.white(serverless.RegionID)
+				chalk.dim(
+					`   Container images are built externally and pulled directly.`
+				)
 			);
+			console.log(
+				chalk.dim(
+					`\n   To view runtime logs, use: boltic serverless logs ${serverless.Config.Name}`
+				)
+			);
+			return;
 		}
-		if (serverless.CreatedAt) {
+
+		// If build ID not provided, fetch builds and let user select
+		if (!buildId) {
 			console.log(
-				chalk.cyan("   Created: ") +
-					chalk.white(new Date(serverless.CreatedAt).toLocaleString())
+				chalk.cyan(
+					`\n🔨 Fetching builds for "${serverless.Config.Name}"...\n`
+				)
 			);
+
+			const buildsData = await getServerlessBuilds(
+				apiUrl,
+				token,
+				accountId,
+				session,
+				serverless.ID
+			);
+
+			if (
+				!buildsData ||
+				!buildsData.data ||
+				buildsData.data.length === 0
+			) {
+				console.log(
+					chalk.yellow("No builds found for this serverless.")
+				);
+				return;
+			}
+
+			const builds = buildsData.data;
+
+			const buildChoices = builds.map((build, index) => {
+				const status =
+					build.StatusHistory?.slice(-1)[0]?.Status ||
+					build.Status ||
+					"unknown";
+				const statusColor = getStatusColor(status);
+				const createdAt = build.CreatedAt
+					? new Date(build.CreatedAt).toLocaleString()
+					: "N/A";
+
+				return {
+					name: `#${index + 1} | ${statusColor(status)} | ${createdAt} | ${build.ID.substring(0, 8)}...`,
+					value: build,
+				};
+			});
+
+			const selectedBuild = await search({
+				message: "Select a build to view logs:",
+				source: async (term) => {
+					if (!term) return buildChoices;
+					return buildChoices.filter((choice) =>
+						choice.name.toLowerCase().includes(term.toLowerCase())
+					);
+				},
+			});
+
+			if (!selectedBuild) {
+				return;
+			}
+
+			buildId = selectedBuild.ID;
 		}
-		if (serverless.UpdatedAt) {
+
+		console.log(chalk.cyan(`\n📜 Fetching build logs...\n`));
+
+		if (follow) {
 			console.log(
-				chalk.cyan("   Updated: ") +
-					chalk.white(new Date(serverless.UpdatedAt).toLocaleString())
+				chalk.dim("Following build logs... Press Ctrl+C to stop.\n")
 			);
 		}
 
-		console.log();
-		console.log(chalk.cyan("━".repeat(60)));
+		console.log(chalk.cyan("━".repeat(80)));
+		console.log(chalk.bold("Build Logs:\n"));
+
+		// Track displayed lines to avoid duplicates in follow mode
+		let displayedLines = 0;
+
+		const fetchAndDisplayBuildLogs = async () => {
+			const logsData = await getBuildLogs(
+				apiUrl,
+				token,
+				accountId,
+				session,
+				serverless.ID,
+				buildId
+			);
+
+			if (!logsData || !logsData.data) {
+				if (!follow && displayedLines === 0) {
+					console.log(chalk.yellow("No logs found for this build."));
+				}
+				return { hasLogs: false, buildComplete: false };
+			}
+
+			// Handle different log formats
+			const logs = Array.isArray(logsData.data)
+				? logsData.data
+				: [logsData.data];
+
+			// Only display new logs (skip already displayed ones)
+			const newLogs = logs.slice(displayedLines);
+
+			newLogs.forEach((log) => {
+				if (typeof log === "string") {
+					console.log(log);
+				} else if (log.Log) {
+					// Log field contains the actual log content (may include ANSI colors)
+					// Output directly to preserve color codes
+					process.stdout.write(log.Log);
+					if (!log.Log.endsWith("\n")) {
+						process.stdout.write("\n");
+					}
+				} else if (log.Message || log.message) {
+					const timestamp = log.Timestamp
+						? new Date(log.Timestamp * 1000).toLocaleTimeString()
+						: "";
+					console.log(
+						chalk.dim(`[${timestamp}]`) +
+							` ${log.Message || log.message}`
+					);
+				} else {
+					console.log(JSON.stringify(log, null, 2));
+				}
+			});
+
+			displayedLines = logs.length;
+
+			// Check if build is complete by looking for completion indicators
+			const lastLog = logs[logs.length - 1];
+			const logContent =
+				typeof lastLog === "string"
+					? lastLog
+					: lastLog?.Log || lastLog?.Message || "";
+			const buildComplete =
+				logContent.includes("Build completed") ||
+				logContent.includes("Build failed") ||
+				logContent.includes("successfully") ||
+				logContent.includes("error:");
+
+			return { hasLogs: true, buildComplete };
+		};
+
+		let result = await fetchAndDisplayBuildLogs();
+
+		if (follow && !result.buildComplete) {
+			// Poll for new logs every 2 seconds until build completes
+			while (true) {
+				await new Promise((resolve) => setTimeout(resolve, 2000));
+				result = await fetchAndDisplayBuildLogs();
+				if (result.buildComplete) {
+					console.log(
+						chalk.dim("\n\nBuild completed. Stopping log follow.")
+					);
+					break;
+				}
+			}
+		}
+
+		console.log("\n" + chalk.cyan("━".repeat(80)));
 	} catch (error) {
 		if (
 			error.message &&