@inkeep/agents-cli 0.39.4 → 0.40.0

package/dist/commands/init.js

@@ -0,0 +1,360 @@
+import { checkKeychainAvailability, loadCredentials } from "../utils/credentials.js";
+import { DEFAULT_PROFILES_CONFIG } from "../utils/profiles/types.js";
+import { ProfileManager } from "../utils/profiles/profile-manager.js";
+import "../utils/profiles/index.js";
+import { loginCommand } from "./login.js";
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+
+//#region src/commands/init.ts
+/**
+* Find the most appropriate directory for the config file by looking for
+* common project root indicators
+*/
+function findProjectRoot(startPath) {
+	let currentPath = resolve(startPath);
+	const root = dirname(currentPath);
+	const rootIndicators = [
+		"package.json",
+		".git",
+		".gitignore",
+		"tsconfig.json",
+		"package-lock.json",
+		"yarn.lock",
+		"pnpm-lock.yaml"
+	];
+	while (currentPath !== root) {
+		const files = readdirSync(currentPath);
+		if (rootIndicators.some((indicator) => files.includes(indicator))) return currentPath;
+		const parentPath = dirname(currentPath);
+		if (parentPath === currentPath) break;
+		currentPath = parentPath;
+	}
+	return startPath;
+}
+async function initCommand(options) {
+	if (options?.local) {
+		await localInitCommand(options);
+		return;
+	}
+	await cloudInitCommand(options);
+}
+/**
+* Full onboarding wizard for Inkeep Cloud customers
+*/
+async function cloudInitCommand(options) {
+	console.log();
+	console.log(chalk.bold("Welcome to Inkeep!"));
+	console.log();
+	const s = p.spinner();
+	const profileManager = new ProfileManager();
+	s.start("Checking authentication...");
+	let isAuthenticated = false;
+	let credentials = null;
+	const { available: keychainAvailable } = await checkKeychainAvailability();
+	if (keychainAvailable) try {
+		const existingCreds = await loadCredentials("inkeep-cloud");
+		if (existingCreds && existingCreds.accessToken && existingCreds.organizationId) {
+			credentials = {
+				accessToken: existingCreds.accessToken,
+				organizationId: existingCreds.organizationId,
+				userEmail: existingCreds.userEmail
+			};
+			isAuthenticated = true;
+			s.stop(`Logged in as ${chalk.cyan(existingCreds.userEmail)}`);
+		}
+	} catch {}
+	if (!isAuthenticated) {
+		s.stop("Not logged in");
+		console.log(chalk.yellow("→ Opening browser for login..."));
+		console.log();
+		await loginCommand({});
+		const newCreds = await loadCredentials("inkeep-cloud");
+		if (newCreds && newCreds.accessToken && newCreds.organizationId) {
+			credentials = {
+				accessToken: newCreds.accessToken,
+				organizationId: newCreds.organizationId,
+				userEmail: newCreds.userEmail
+			};
+			isAuthenticated = true;
+		} else {
+			console.error(chalk.red("Login failed. Please try again."));
+			process.exit(1);
+		}
+	}
+	s.start("Fetching your organizations...");
+	let selectedTenantId;
+	let selectedTenantName;
+	try {
+		const response = await fetch("https://manage-api.inkeep.com/api/cli/me", { headers: { Authorization: `Bearer ${credentials.accessToken}` } });
+		if (!response.ok) {
+			s.stop("Failed to fetch organizations");
+			console.error(chalk.red("Could not fetch your organizations. Please try logging in again."));
+			process.exit(1);
+		}
+		const data = await response.json();
+		selectedTenantId = data.organization.id;
+		selectedTenantName = data.organization.name;
+		s.stop(`Organization: ${chalk.cyan(selectedTenantName)}`);
+	} catch (error) {
+		s.stop("Failed to fetch organizations");
+		console.error(chalk.red("Network error. Please check your connection."));
+		process.exit(1);
+	}
+	s.start(`Fetching projects for ${selectedTenantName}...`);
+	let projects = [];
+	try {
+		const response = await fetch(`https://manage-api.inkeep.com/tenants/${selectedTenantId}/projects?limit=100`, { headers: { Authorization: `Bearer ${credentials.accessToken}` } });
+		if (!response.ok) {
+			s.stop("Failed to fetch projects");
+			console.error(chalk.red("Could not fetch projects."));
+			process.exit(1);
+		}
+		projects = (await response.json()).data || [];
+		s.stop(`Found ${projects.length} project(s)`);
+	} catch (error) {
+		s.stop("Failed to fetch projects");
+		console.error(chalk.red("Network error. Please check your connection."));
+		process.exit(1);
+	}
+	let targetDir;
+	if (options?.path) targetDir = resolve(process.cwd(), options.path);
+	else {
+		const suggestedPath = "./inkeep-agents";
+		const confirmedPath = await p.text({
+			message: "Where should we create the project files?",
+			placeholder: suggestedPath,
+			initialValue: suggestedPath,
+			validate: (input) => {
+				if (!input || input.trim() === "") return "Path is required";
+			}
+		});
+		if (p.isCancel(confirmedPath)) {
+			p.cancel("Setup cancelled");
+			process.exit(0);
+		}
+		targetDir = resolve(process.cwd(), confirmedPath);
+	}
+	if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true });
+	console.log();
+	console.log(chalk.bold("Creating directory structure..."));
+	const createdProjects = [];
+	if (projects.length === 0) {
+		const templateDir = join(targetDir, "my-agent");
+		mkdirSync(templateDir, { recursive: true });
+		const configContent = generateConfigFile(selectedTenantId, "my-agent");
+		writeFileSync(join(templateDir, "inkeep.config.ts"), configContent);
+		const indexContent = generateIndexFile("my-agent");
+		writeFileSync(join(templateDir, "index.ts"), indexContent);
+		console.log(chalk.gray(`  ${targetDir}/`));
+		console.log(chalk.gray(`    └── my-agent/`));
+		console.log(chalk.gray(`        ├── inkeep.config.ts`));
+		console.log(chalk.gray(`        └── index.ts`));
+		createdProjects.push("my-agent");
+	} else {
+		console.log(chalk.gray(`  ${targetDir}/`));
+		for (const project of projects) {
+			const projectDir = join(targetDir, sanitizeProjectName(project.name || project.id));
+			mkdirSync(projectDir, { recursive: true });
+			const configContent = generateConfigFile(selectedTenantId, project.id);
+			writeFileSync(join(projectDir, "inkeep.config.ts"), configContent);
+			const indexContent = generateIndexFile(project.id);
+			writeFileSync(join(projectDir, "index.ts"), indexContent);
+			const displayName = sanitizeProjectName(project.name || project.id);
+			console.log(chalk.gray(`    ├── ${displayName}/`));
+			console.log(chalk.gray(`    │   ├── inkeep.config.ts`));
+			console.log(chalk.gray(`    │   └── index.ts`));
+			createdProjects.push(displayName);
+		}
+	}
+	console.log();
+	console.log(chalk.green(`✓ Created ${createdProjects.length} project(s)`));
+	console.log();
+	console.log(chalk.bold("Creating environment templates..."));
+	const envDevContent = generateEnvTemplate("development");
+	const envProdContent = generateEnvTemplate("production");
+	writeFileSync(join(targetDir, ".env.development"), envDevContent);
+	writeFileSync(join(targetDir, ".env.production"), envProdContent);
+	console.log(chalk.green("  ✓ .env.development"));
+	console.log(chalk.green("  ✓ .env.production"));
+	if (!profileManager.profilesFileExists()) {
+		console.log();
+		console.log(chalk.bold("Setting up profile..."));
+		profileManager.saveProfiles(DEFAULT_PROFILES_CONFIG);
+		console.log(chalk.green("  ✓ Created cloud profile"));
+	}
+	console.log();
+	console.log(chalk.green.bold("Setup complete!"));
+	console.log();
+	console.log(chalk.bold("Next steps:"));
+	console.log(chalk.gray(`  1. cd ${targetDir}`));
+	console.log(chalk.gray("  2. Add your API keys to .env.development"));
+	if (projects.length > 0) console.log(chalk.gray("  3. Run: inkeep pull --all"));
+	else {
+		console.log(chalk.gray("  3. Define your agent in index.ts"));
+		console.log(chalk.gray("  4. Run: inkeep push"));
+	}
+	console.log();
+}
+/**
+* Simple local init for self-hosted deployments
+*/
+async function localInitCommand(options) {
+	let configPath;
+	if (options?.path) {
+		const resolvedPath = resolve(process.cwd(), options.path);
+		if (options.path.endsWith(".ts") || options.path.endsWith(".js")) configPath = resolvedPath;
+		else configPath = join(resolvedPath, "inkeep.config.ts");
+	} else {
+		const suggestedPath = join(findProjectRoot(process.cwd()), "inkeep.config.ts");
+		if (options?.interactive === false) configPath = suggestedPath;
+		else {
+			const confirmedPath = await p.text({
+				message: "Where should the config file be created?",
+				initialValue: suggestedPath,
+				validate: (input) => {
+					if (!input || input.trim() === "") return "Path is required";
+					const dir = input.endsWith(".ts") || input.endsWith(".js") ? dirname(input) : input;
+					const resolvedDir = resolve(process.cwd(), dir);
+					if (!existsSync(resolvedDir)) return `Directory does not exist: ${resolvedDir}`;
+				}
+			});
+			if (p.isCancel(confirmedPath)) {
+				p.cancel("Operation cancelled");
+				process.exit(0);
+			}
+			const resolvedPath = resolve(process.cwd(), confirmedPath);
+			configPath = confirmedPath.endsWith(".ts") || confirmedPath.endsWith(".js") ? resolvedPath : join(resolvedPath, "inkeep.config.ts");
+		}
+	}
+	if (existsSync(configPath)) {
+		const overwrite = await p.confirm({
+			message: `${basename(configPath)} already exists. Overwrite?`,
+			initialValue: false
+		});
+		if (p.isCancel(overwrite)) {
+			p.cancel("Operation cancelled");
+			process.exit(0);
+		}
+		if (!overwrite) {
+			console.log(chalk.yellow("Init cancelled."));
+			return;
+		}
+	}
+	const tenantId = await p.text({
+		message: "Enter your tenant ID:",
+		validate: (input) => {
+			if (!input || input.trim() === "") return "Tenant ID is required";
+		}
+	});
+	if (p.isCancel(tenantId)) {
+		p.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	const validateUrl = (input) => {
+		try {
+			if (input && input.trim() !== "") {
+				new URL(input);
+				return;
+			}
+			return;
+		} catch {
+			return "Please enter a valid URL";
+		}
+	};
+	const manageApiUrl = await p.text({
+		message: "Enter the Management API URL:",
+		placeholder: "http://localhost:3002",
+		initialValue: "http://localhost:3002",
+		validate: validateUrl
+	});
+	if (p.isCancel(manageApiUrl)) {
+		p.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	const runApiUrl = await p.text({
+		message: "Enter the Run API URL:",
+		placeholder: "http://localhost:3003",
+		initialValue: "http://localhost:3003",
+		validate: validateUrl
+	});
+	if (p.isCancel(runApiUrl)) {
+		p.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	const configContent = `import { defineConfig } from '@inkeep/agents-cli/config';
+
+export default defineConfig({
+  tenantId: '${tenantId}',
+  agentsManageApi: {
+    url: '${manageApiUrl}',
+  },
+  agentsRunApi: {
+    url: '${runApiUrl}',
+  },
+});
+`;
+	try {
+		writeFileSync(configPath, configContent);
+		console.log(chalk.green("✓"), `Created ${chalk.cyan(configPath)}`);
+		console.log(chalk.gray("\nYou can now use the Inkeep CLI commands."));
+		const configDir = dirname(configPath);
+		if (configDir !== process.cwd()) {
+			console.log(chalk.gray(`\nNote: Config file created in ${configDir}`));
+			console.log(chalk.gray(`Use --config ${configPath} with commands, or run commands from that directory.`));
+		}
+	} catch (error) {
+		console.error(chalk.red("Failed to create config file:"), error);
+		process.exit(1);
+	}
+}
+function sanitizeProjectName(name) {
+	return name.toLowerCase().replace(/[^a-z0-9-_]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function generateConfigFile(tenantId, projectId) {
+	return `import { defineConfig } from '@inkeep/agents-cli/config';
+
+export default defineConfig({
+  tenantId: '${tenantId}',
+  projectId: '${projectId}',
+  agentsManageApi: {
+    url: 'https://manage-api.inkeep.com',
+  },
+  agentsRunApi: {
+    url: 'https://run-api.inkeep.com',
+  },
+});
+`;
+}
+function generateIndexFile(projectId) {
+	return `import { project } from '@inkeep/agents-sdk';
+
+// This file was auto-generated by 'inkeep init'
+// Run 'inkeep pull' to sync with your remote project
+
+export default project({
+  id: '${projectId}',
+  name: '${projectId}',
+  agents: {},
+  tools: {},
+});
+`;
+}
+function generateEnvTemplate(environment) {
+	return `# ${environment.charAt(0).toUpperCase() + environment.slice(1)} Environment
+# Add your API keys and secrets here
+
+# OpenAI API Key
+OPENAI_API_KEY=sk-your-key-here
+
+# Anthropic API Key
+ANTHROPIC_API_KEY=sk-ant-your-key-here
+
+# Add other provider keys as needed
+`;
+}
+
+//#endregion
+export { initCommand };

package/dist/commands/list-agents.js

@@ -0,0 +1,56 @@
+import { ManagementApiClient } from "../api.js";
+import { initializeCommand } from "../utils/cli-pipeline.js";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import Table from "cli-table3";
+
+//#region src/commands/list-agents.ts
+async function listAgentsCommand(options) {
+	const configPath = options.config || options.configFilePath;
+	const { config } = await initializeCommand({
+		configPath,
+		showSpinner: false,
+		logConfig: true
+	});
+	console.log();
+	const api = await ManagementApiClient.create(config.agentsManageApiUrl, configPath, config.tenantId, options.project);
+	const s = p.spinner();
+	s.start("Fetching agent...");
+	try {
+		const agents = await api.listAgents();
+		s.stop(`Found ${agents.length} agent(s) in project "${options.project}"`);
+		if (agents.length === 0) {
+			console.log(chalk.gray(`No agent found in project "${options.project}". Define agent in your project and run: inkeep push`));
+			return;
+		}
+		const table = new Table({
+			head: [
+				chalk.cyan("Agent ID"),
+				chalk.cyan("Name"),
+				chalk.cyan("Default Agent"),
+				chalk.cyan("Created")
+			],
+			style: {
+				head: [],
+				border: []
+			}
+		});
+		for (const agent of agents) {
+			const createdDate = agent.createdAt ? new Date(agent.createdAt).toLocaleDateString() : "Unknown";
+			table.push([
+				agent.id || "",
+				agent.name || agent.id || "",
+				agent.defaultSubAgentId || chalk.gray("None"),
+				createdDate
+			]);
+		}
+		console.log(`\n${table.toString()}`);
+	} catch (error) {
+		s.stop("Failed to fetch agent");
+		console.error(chalk.red("Error:"), error instanceof Error ? error.message : error);
+		process.exit(1);
+	}
+}
+
+//#endregion
+export { listAgentsCommand };

package/dist/commands/login.js

@@ -0,0 +1,179 @@
+import { checkKeychainAvailability, getKeychainUnavailableMessage, loadCredentials, saveCredentials } from "../utils/credentials.js";
+import { ProfileManager } from "../utils/profiles/profile-manager.js";
+import "../utils/profiles/index.js";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import open from "open";
+
+//#region src/commands/login.ts
+/**
+* Format user code as XXXX-XXXX for display
+*/
+function formatUserCode(code) {
+	const cleaned = code.replace(/[^A-Z0-9]/gi, "").toUpperCase();
+	if (cleaned.length === 8) return `${cleaned.slice(0, 4)}-${cleaned.slice(4)}`;
+	return cleaned;
+}
+/**
+* Sleep for a specified number of milliseconds
+*/
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Poll the device token endpoint until authorization is complete
+*/
+async function pollForToken(cloudUrl, deviceCode, clientId, initialInterval) {
+	let interval = initialInterval;
+	while (true) {
+		await sleep(interval * 1e3);
+		const data = await (await fetch(`${cloudUrl}/api/auth/device/token`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({
+				grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+				device_code: deviceCode,
+				client_id: clientId
+			})
+		})).json();
+		if (data.access_token) return data.access_token;
+		if (data.error === "authorization_pending") continue;
+		if (data.error === "slow_down") {
+			interval += 5;
+			continue;
+		}
+		if (data.error === "expired_token") throw new Error("Device code expired. Please try again.");
+		if (data.error === "access_denied") throw new Error("Authorization denied.");
+		throw new Error(data.error || data.message || "Unknown error during authorization");
+	}
+}
+/**
+* Fetch user info and organization after authentication
+*/
+async function fetchUserInfo(cloudUrl, accessToken) {
+	const sessionResponse = await fetch(`${cloudUrl}/api/auth/get-session`, { headers: { Authorization: `Bearer ${accessToken}` } });
+	if (!sessionResponse.ok) throw new Error("Failed to fetch user session");
+	const user = (await sessionResponse.json()).user;
+	if (!user) throw new Error("No user found in session");
+	const orgResponse = await fetch(`${cloudUrl}/api/cli/me`, { headers: { Authorization: `Bearer ${accessToken}` } });
+	if (!orgResponse.ok) throw new Error("Failed to fetch organization info. Please ensure that you are a member of an organization.");
+	const orgData = await orgResponse.json();
+	return {
+		user: {
+			id: user.id,
+			email: user.email,
+			name: user.name
+		},
+		organization: orgData.organization
+	};
+}
+async function loginCommand(options = {}) {
+	const profileManager = new ProfileManager();
+	let profileName;
+	let credentialKey;
+	let manageApiUrl;
+	let manageUiUrl;
+	try {
+		if (options.profile) {
+			const profile = profileManager.getProfile(options.profile);
+			if (!profile) {
+				console.error(chalk.red(`Profile '${options.profile}' not found.`));
+				console.log(chalk.gray("Run \"inkeep profile list\" to see available profiles."));
+				process.exit(1);
+			}
+			profileName = options.profile;
+			credentialKey = profile.credential;
+			manageApiUrl = profile.remote.manageApi;
+			manageUiUrl = profile.remote.manageUi;
+		} else {
+			const activeProfile = profileManager.getActiveProfile();
+			profileName = activeProfile.name;
+			credentialKey = activeProfile.credential;
+			manageApiUrl = activeProfile.remote.manageApi;
+			manageUiUrl = activeProfile.remote.manageUi;
+		}
+	} catch {
+		profileName = "default";
+		credentialKey = "inkeep-cloud";
+		manageApiUrl = "https://manage-api.inkeep.com";
+		manageUiUrl = "https://manage.inkeep.com";
+	}
+	console.log(chalk.gray(`Using profile: ${profileName}`));
+	const { available, reason } = await checkKeychainAvailability();
+	if (!available) {
+		console.error(chalk.red("Error:"), getKeychainUnavailableMessage(reason));
+		console.log();
+		console.log(chalk.yellow("For CI/CD environments without keychain access:"));
+		console.log(chalk.gray("  Set INKEEP_API_KEY environment variable instead of using login."));
+		console.log(chalk.gray("  See: https://docs.inkeep.com/cli/cicd"));
+		process.exit(1);
+	}
+	const existingCredentials = await loadCredentials(credentialKey);
+	if (existingCredentials) {
+		const continueLogin = await p.confirm({
+			message: `Already logged in as ${chalk.cyan(existingCredentials.userEmail)} for profile '${profileName}'. Continue with new login?`,
+			initialValue: false
+		});
+		if (p.isCancel(continueLogin)) {
+			p.cancel("Login cancelled");
+			process.exit(0);
+		}
+		if (!continueLogin) {
+			console.log(chalk.gray("Login cancelled. You are still logged in."));
+			return;
+		}
+	}
+	const s = p.spinner();
+	try {
+		s.start("Requesting device code...");
+		const deviceCodeResponse = await fetch(`${manageApiUrl}/api/auth/device/code`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ client_id: "inkeep-cli" })
+		});
+		if (!deviceCodeResponse.ok) {
+			const errorData = await deviceCodeResponse.json().catch(() => ({}));
+			throw new Error(errorData.message || `Failed to get device code: ${deviceCodeResponse.statusText}`);
+		}
+		const { device_code, user_code, interval } = await deviceCodeResponse.json();
+		s.stop("Device code received");
+		console.log();
+		console.log(chalk.bold("To authenticate, visit:"));
+		console.log(chalk.cyan(`  ${manageUiUrl}/device?user_code=${user_code}`));
+		console.log();
+		console.log(chalk.bold("And enter code:"));
+		console.log(chalk.yellow.bold(`  ${formatUserCode(user_code)}`));
+		console.log();
+		try {
+			await open(`${manageUiUrl}/device?user_code=${user_code}`);
+			console.log(chalk.gray("  (Browser opened automatically)"));
+			console.log();
+		} catch {}
+		s.start("Waiting for authorization...");
+		const accessToken = await pollForToken(manageApiUrl, device_code, "inkeep-cli", interval || 5);
+		s.stop("Authorized!");
+		s.start("Fetching account info...");
+		const userInfo = await fetchUserInfo(manageApiUrl, accessToken);
+		s.stop("Account info retrieved");
+		await saveCredentials({
+			accessToken,
+			userId: userInfo.user.id,
+			userEmail: userInfo.user.email,
+			organizationId: userInfo.organization.id,
+			organizationName: userInfo.organization.name,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		}, credentialKey);
+		console.log();
+		console.log(chalk.green("✓"), `Logged in as ${chalk.cyan(userInfo.user.email)}`);
+		console.log(chalk.green("✓"), `Organization: ${chalk.cyan(userInfo.organization.name)}`);
+		console.log(chalk.green("✓"), `Profile: ${chalk.cyan(profileName)}`);
+	} catch (error) {
+		s.stop("Login failed");
+		const errorMessage = error instanceof Error ? error.message : "Unknown error";
+		console.error(chalk.red("Error:"), errorMessage);
+		process.exit(1);
+	}
+}
+
+//#endregion
+export { loginCommand };

package/dist/commands/logout.js

@@ -0,0 +1,56 @@
+import { clearCredentials, loadCredentials } from "../utils/credentials.js";
+import { ProfileManager } from "../utils/profiles/profile-manager.js";
+import "../utils/profiles/index.js";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+
+//#region src/commands/logout.ts
+async function logoutCommand(options = {}) {
+	const profileManager = new ProfileManager();
+	const s = p.spinner();
+	let profileName;
+	let credentialKey;
+	try {
+		if (options.profile) {
+			const profile = profileManager.getProfile(options.profile);
+			if (!profile) {
+				console.error(chalk.red(`Profile '${options.profile}' not found.`));
+				console.log(chalk.gray("Run \"inkeep profile list\" to see available profiles."));
+				process.exit(1);
+			}
+			profileName = options.profile;
+			credentialKey = profile.credential;
+		} else {
+			const activeProfile = profileManager.getActiveProfile();
+			profileName = activeProfile.name;
+			credentialKey = activeProfile.credential;
+		}
+	} catch {
+		profileName = "default";
+		credentialKey = "inkeep-cloud";
+	}
+	console.log(chalk.gray(`Using profile: ${profileName}`));
+	if (!await loadCredentials(credentialKey)) {
+		console.log(chalk.yellow(`Not logged in for profile '${profileName}'.`));
+		return;
+	}
+	s.start("Logging out...");
+	try {
+		if (await clearCredentials(credentialKey)) {
+			s.stop("Logged out successfully");
+			console.log(chalk.green("✓"), `Logged out from profile '${chalk.cyan(profileName)}'.`);
+			console.log(chalk.gray(`  • Credential '${credentialKey}' removed from keychain.`));
+		} else {
+			s.stop("Logout completed");
+			console.log(chalk.gray("No credentials were stored."));
+		}
+	} catch (error) {
+		s.stop("Logout failed");
+		const errorMessage = error instanceof Error ? error.message : "Unknown error";
+		console.error(chalk.red("Error:"), errorMessage);
+		process.exit(1);
+	}
+}
+
+//#endregion
+export { logoutCommand };