@inkeep/agents-cli 0.39.5 → 0.40.0

package/dist/utils/mcp-runner.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import http from "node:http";
+
+//#region src/utils/mcp-runner.ts
+/**
+* MCP Runner - Loads and starts MCP servers from an agent file
+* This is executed as a subprocess by the CLI
+*/
+const MCP_DIR = join(homedir(), ".inkeep", "mcp");
+const REGISTRY_FILE = join(MCP_DIR, "servers.json");
+if (!existsSync(MCP_DIR)) mkdirSync(MCP_DIR, { recursive: true });
+async function startServers(agentPath$1) {
+	try {
+		const module = await import(agentPath$1);
+		const servers = module.servers || module.tools || [];
+		let agentId = "unknown";
+		if (module.agent && typeof module.agent.getId === "function") agentId = module.agent.getId();
+		const registeredServers = [];
+		let nextPort = 3100;
+		for (const server of servers) {
+			if (!server) continue;
+			const name = server.name || "unnamed";
+			const id = server.id || name;
+			const description = server.description || "";
+			if (typeof server.execute === "function" || typeof server.init === "function" || !server.serverUrl) {
+				const port = server.port || nextPort++;
+				if (typeof server.init === "function") await server.init();
+				if (typeof server.execute === "function") http.createServer(async (req, res) => {
+					if (req.method === "POST" && req.url === "/mcp") {
+						let body = "";
+						req.on("data", (chunk) => body += chunk);
+						req.on("end", async () => {
+							try {
+								const params = JSON.parse(body);
+								const result = await server.execute(params);
+								res.writeHead(200, { "Content-Type": "application/json" });
+								res.end(JSON.stringify({ result }));
+							} catch (error) {
+								res.writeHead(500, { "Content-Type": "application/json" });
+								res.end(JSON.stringify({ error: error.message }));
+							}
+						});
+					} else {
+						res.writeHead(404);
+						res.end("Not Found");
+					}
+				}).listen(port, () => {
+					console.log(JSON.stringify({
+						type: "server_started",
+						name,
+						port,
+						deployment: "local"
+					}));
+				});
+				registeredServers.push({
+					pid: process.pid,
+					agentId,
+					toolId: id,
+					name,
+					port,
+					deployment: "local",
+					transport: "http",
+					command: agentPath$1,
+					startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					description
+				});
+			} else {
+				registeredServers.push({
+					pid: process.pid,
+					agentId,
+					toolId: id,
+					name,
+					serverUrl: server.serverUrl || server.getServerUrl?.(),
+					deployment: "remote",
+					transport: server.transport || "http",
+					command: agentPath$1,
+					startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					description
+				});
+				console.log(JSON.stringify({
+					type: "server_registered",
+					name,
+					serverUrl: server.serverUrl,
+					deployment: "remote"
+				}));
+			}
+		}
+		writeFileSync(REGISTRY_FILE, JSON.stringify({ servers: registeredServers }, null, 2));
+		console.log(JSON.stringify({
+			type: "all_started",
+			count: registeredServers.length
+		}));
+		process.stdin.resume();
+		process.on("SIGINT", () => {
+			console.log(JSON.stringify({ type: "shutting_down" }));
+			process.exit(0);
+		});
+	} catch (error) {
+		console.error(JSON.stringify({
+			type: "error",
+			message: error.message
+		}));
+		process.exit(1);
+	}
+}
+const agentPath = process.argv[2];
+if (!agentPath) {
+	console.error(JSON.stringify({
+		type: "error",
+		message: "Agent path is required"
+	}));
+	process.exit(1);
+}
+startServers(agentPath);
+
+//#endregion
+export {  };

package/dist/utils/model-config.js

@@ -0,0 +1,182 @@
+import { ANTHROPIC_MODELS, GOOGLE_MODELS, OPENAI_MODELS } from "@inkeep/agents-core";
+import * as p from "@clack/prompts";
+
+//#region src/utils/model-config.ts
+const defaultGeminiModelConfigurations = {
+	base: { model: GOOGLE_MODELS.GEMINI_2_5_FLASH },
+	structuredOutput: { model: GOOGLE_MODELS.GEMINI_2_5_FLASH_LITE },
+	summarizer: { model: GOOGLE_MODELS.GEMINI_2_5_FLASH_LITE }
+};
+const defaultOpenaiModelConfigurations = {
+	base: { model: OPENAI_MODELS.GPT_5_2 },
+	structuredOutput: { model: OPENAI_MODELS.GPT_4_1_MINI },
+	summarizer: { model: OPENAI_MODELS.GPT_4_1_NANO }
+};
+const defaultAnthropicModelConfigurations = {
+	base: { model: ANTHROPIC_MODELS.CLAUDE_SONNET_4_5 },
+	structuredOutput: { model: ANTHROPIC_MODELS.CLAUDE_SONNET_4_5 },
+	summarizer: { model: ANTHROPIC_MODELS.CLAUDE_SONNET_4_5 }
+};
+/**
+* Prompt user for model configuration (providers and model selection)
+* This is shared between init and push commands
+*/
+async function promptForModelConfiguration() {
+	const providers = await p.multiselect({
+		message: "Which AI providers would you like to configure?",
+		options: [
+			{
+				value: "anthropic",
+				label: "Anthropic (Claude)"
+			},
+			{
+				value: "openai",
+				label: "OpenAI (GPT)"
+			},
+			{
+				value: "google",
+				label: "Google (Gemini)"
+			}
+		],
+		required: true
+	});
+	if (p.isCancel(providers)) {
+		p.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	const anthropicModels = [
+		{
+			label: "Claude Opus 4.5",
+			value: ANTHROPIC_MODELS.CLAUDE_OPUS_4_5
+		},
+		{
+			label: "Claude Opus 4.1",
+			value: ANTHROPIC_MODELS.CLAUDE_OPUS_4_1
+		},
+		{
+			label: "Claude Sonnet 4.5",
+			value: ANTHROPIC_MODELS.CLAUDE_SONNET_4_5
+		},
+		{
+			label: "Claude Sonnet 4",
+			value: ANTHROPIC_MODELS.CLAUDE_SONNET_4
+		},
+		{
+			label: "Claude Haiku 4.5",
+			value: ANTHROPIC_MODELS.CLAUDE_HAIKU_4_5
+		},
+		{
+			label: "Claude Haiku 3.5",
+			value: ANTHROPIC_MODELS.CLAUDE_3_5_HAIKU
+		}
+	];
+	const openaiModels = [
+		{
+			label: "GPT-5.2",
+			value: OPENAI_MODELS.GPT_5_2
+		},
+		{
+			label: "GPT-5.1",
+			value: OPENAI_MODELS.GPT_5_1
+		},
+		{
+			label: "GPT-4.1",
+			value: OPENAI_MODELS.GPT_4_1
+		},
+		{
+			label: "GPT-4.1 Mini",
+			value: OPENAI_MODELS.GPT_4_1_MINI
+		},
+		{
+			label: "GPT-4.1 Nano",
+			value: OPENAI_MODELS.GPT_4_1_NANO
+		},
+		{
+			label: "GPT-5",
+			value: OPENAI_MODELS.GPT_5
+		},
+		{
+			label: "GPT-5 Mini",
+			value: OPENAI_MODELS.GPT_5_MINI
+		},
+		{
+			label: "GPT-5 Nano",
+			value: OPENAI_MODELS.GPT_5_NANO
+		}
+	];
+	const googleModels = [
+		{
+			label: "Gemini 3 Pro Preview",
+			value: GOOGLE_MODELS.GEMINI_3_PRO_PREVIEW
+		},
+		{
+			label: "Gemini 3 Flash Preview",
+			value: GOOGLE_MODELS.GEMINI_3_FLASH_PREVIEW
+		},
+		{
+			label: "Gemini 2.5 Pro",
+			value: GOOGLE_MODELS.GEMINI_2_5_PRO
+		},
+		{
+			label: "Gemini 2.5 Flash",
+			value: GOOGLE_MODELS.GEMINI_2_5_FLASH
+		},
+		{
+			label: "Gemini 2.5 Flash Lite",
+			value: GOOGLE_MODELS.GEMINI_2_5_FLASH_LITE
+		}
+	];
+	const availableModels = [];
+	if (providers.includes("anthropic")) availableModels.push(...anthropicModels);
+	if (providers.includes("openai")) availableModels.push(...openaiModels);
+	if (providers.includes("google")) availableModels.push(...googleModels);
+	const baseModel = await p.select({
+		message: "Select your default model for general tasks (required):",
+		options: availableModels
+	});
+	if (p.isCancel(baseModel)) {
+		p.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	const configureOptionalModels = await p.confirm({
+		message: "Would you like to configure optional models for structured output and summaries?",
+		initialValue: false
+	});
+	if (p.isCancel(configureOptionalModels)) {
+		p.cancel("Operation cancelled");
+		process.exit(0);
+	}
+	let structuredOutputModel = null;
+	let summarizerModel = null;
+	if (configureOptionalModels) {
+		const optionalChoices = [...availableModels, {
+			label: "Use base model",
+			value: null
+		}];
+		const structuredOutputResponse = await p.select({
+			message: "Select your model for structured output tasks (or use base model):",
+			options: optionalChoices
+		});
+		if (p.isCancel(structuredOutputResponse)) {
+			p.cancel("Operation cancelled");
+			process.exit(0);
+		}
+		structuredOutputModel = structuredOutputResponse;
+		const summarizerResponse = await p.select({
+			message: "Select your model for summaries and quick tasks (or use base model):",
+			options: optionalChoices
+		});
+		if (p.isCancel(summarizerResponse)) {
+			p.cancel("Operation cancelled");
+			process.exit(0);
+		}
+		summarizerModel = summarizerResponse;
+	}
+	const modelSettings = { base: { model: baseModel } };
+	if (structuredOutputModel) modelSettings.structuredOutput = { model: structuredOutputModel };
+	if (summarizerModel) modelSettings.summarizer = { model: summarizerModel };
+	return { modelSettings };
+}
+
+//#endregion
+export { defaultAnthropicModelConfigurations, defaultGeminiModelConfigurations, defaultOpenaiModelConfigurations, promptForModelConfiguration };

package/dist/utils/package-manager.js

@@ -0,0 +1,58 @@
+import { DEFAULT_PACKAGE_NAME } from "./version-check.js";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+//#region src/utils/package-manager.ts
+const execAsync = promisify(exec);
+/**
+* Detect which package manager was used to install the CLI globally
+*/
+async function detectPackageManager() {
+	for (const manager of [
+		"pnpm",
+		"bun",
+		"npm",
+		"yarn"
+	]) try {
+		if (manager === "npm") {
+			const { stdout } = await execAsync(`npm list -g ${DEFAULT_PACKAGE_NAME} --depth=0`);
+			if (stdout.includes(DEFAULT_PACKAGE_NAME)) return "npm";
+		} else if (manager === "pnpm") {
+			const { stdout } = await execAsync(`pnpm list -g ${DEFAULT_PACKAGE_NAME} --depth=0`);
+			if (stdout.includes(DEFAULT_PACKAGE_NAME)) return "pnpm";
+		} else if (manager === "bun") {
+			const { stdout } = await execAsync("bun pm ls -g");
+			if (stdout.includes(DEFAULT_PACKAGE_NAME)) return "bun";
+		} else if (manager === "yarn") {
+			const { stdout } = await execAsync("yarn global list");
+			if (stdout.includes(DEFAULT_PACKAGE_NAME)) return "yarn";
+		}
+	} catch {}
+	return null;
+}
+/**
+* Get the update command for a specific package manager
+*/
+function getUpdateCommand(manager, packageName = DEFAULT_PACKAGE_NAME) {
+	switch (manager) {
+		case "npm": return `npm install -g ${packageName}@latest`;
+		case "pnpm": return `pnpm add -g ${packageName}@latest`;
+		case "bun": return `bun add -g ${packageName}@latest`;
+		case "yarn": return `yarn global add ${packageName}@latest`;
+	}
+}
+/**
+* Execute update command
+*/
+async function executeUpdate(manager) {
+	if (![
+		"npm",
+		"pnpm",
+		"bun",
+		"yarn"
+	].includes(manager)) throw new Error(`Unsupported package manager: ${manager}`);
+	await execAsync(getUpdateCommand(manager));
+}
+
+//#endregion
+export { detectPackageManager, executeUpdate, getUpdateCommand };

package/dist/utils/profile-config.js

@@ -0,0 +1,85 @@
+import { getCredentialExpiryInfo, loadCredentials } from "./credentials.js";
+import { ProfileManager } from "./profiles/profile-manager.js";
+import "./profiles/index.js";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import dotenv from "dotenv";
+
+//#region src/utils/profile-config.ts
+async function resolveProfileConfig(options = {}) {
+	const profileManager = new ProfileManager();
+	let profile;
+	let profileName;
+	try {
+		if (options.profileName) {
+			const foundProfile = profileManager.getProfile(options.profileName);
+			if (!foundProfile) {
+				console.error(chalk.red(`Profile '${options.profileName}' not found.`));
+				console.log(chalk.gray("Run \"inkeep profile list\" to see available profiles."));
+				process.exit(1);
+			}
+			profile = foundProfile;
+			profileName = options.profileName;
+		} else {
+			profile = profileManager.getActiveProfile();
+			profileName = profile.name;
+		}
+	} catch {
+		return {
+			profileName: "default",
+			agentsManageApiUrl: "http://localhost:3002",
+			agentsRunApiUrl: "http://localhost:3003",
+			manageUiUrl: "http://localhost:3000",
+			environment: "development",
+			credentialKey: "auth-credentials",
+			isAuthenticated: false
+		};
+	}
+	const credentials = await loadCredentials(profile.credential);
+	let accessToken;
+	let isAuthenticated = false;
+	let authExpiry;
+	if (credentials) {
+		const expiryInfo = getCredentialExpiryInfo(credentials);
+		if (!expiryInfo.isExpired) {
+			accessToken = credentials.accessToken;
+			isAuthenticated = true;
+			authExpiry = expiryInfo.expiresIn;
+		}
+	}
+	if (options.projectDir && profile.environment) {
+		const envFile = join(options.projectDir, `.env.${profile.environment}`);
+		if (existsSync(envFile)) dotenv.config({ path: envFile });
+	}
+	return {
+		profileName,
+		tenantId: credentials?.organizationId,
+		agentsManageApiUrl: profile.remote.manageApi,
+		agentsRunApiUrl: profile.remote.runApi,
+		manageUiUrl: profile.remote.manageUi,
+		environment: profile.environment,
+		credentialKey: profile.credential,
+		accessToken,
+		isAuthenticated,
+		authExpiry
+	};
+}
+function logProfileConfig(config, quiet = false) {
+	if (quiet) return;
+	console.log(chalk.gray(`Using profile: ${chalk.cyan(config.profileName)}`));
+	console.log(chalk.gray(`  Remote: ${config.agentsManageApiUrl}`));
+	console.log(chalk.gray(`  Environment: ${config.environment}`));
+	if (config.isAuthenticated) {
+		const expiryText = config.authExpiry ? ` (expires in ${config.authExpiry})` : "";
+		console.log(chalk.gray(`  Auth: ${chalk.green("authenticated")}${expiryText}`));
+	} else console.log(chalk.gray(`  Auth: ${chalk.yellow("not authenticated")}`));
+}
+function getAuthHeaders(config) {
+	const headers = {};
+	if (config.accessToken) headers["Authorization"] = `Bearer ${config.accessToken}`;
+	return headers;
+}
+
+//#endregion
+export { getAuthHeaders, logProfileConfig, resolveProfileConfig };

package/dist/utils/profiles/index.js

@@ -0,0 +1,4 @@
+import { CLOUD_REMOTE, DEFAULT_CLOUD_PROFILE, DEFAULT_PROFILES_CONFIG, explicitRemoteSchema, profileNameSchema, profileSchema, profilesConfigSchema, remoteSchema } from "./types.js";
+import { ProfileError, ProfileManager, profileManager } from "./profile-manager.js";
+
+export { CLOUD_REMOTE, DEFAULT_CLOUD_PROFILE, DEFAULT_PROFILES_CONFIG, ProfileError, ProfileManager, explicitRemoteSchema, profileManager, profileNameSchema, profileSchema, profilesConfigSchema, remoteSchema };

package/dist/utils/profiles/profile-manager.js

@@ -0,0 +1,219 @@
+import { __require } from "../../_virtual/rolldown_runtime.js";
+import { CLOUD_REMOTE, DEFAULT_PROFILES_CONFIG, profileNameSchema, profilesConfigSchema } from "./types.js";
+import { getLogger } from "@inkeep/agents-core";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import * as yaml from "yaml";
+
+//#region src/utils/profiles/profile-manager.ts
+const logger = getLogger("profile-manager");
+/**
+* Error thrown when profile operations fail
+*/
+var ProfileError = class extends Error {
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "ProfileError";
+	}
+};
+/**
+* Format Zod errors into a human-readable message
+* Compatible with both Zod v3 (errors) and Zod v4 (issues)
+*/
+function formatZodErrors(error) {
+	const issues = error.issues ?? error.errors ?? [];
+	if (!Array.isArray(issues) || issues.length === 0) return error.message || "Validation failed";
+	return issues.map((err) => {
+		return `${err.path && err.path.length > 0 ? `at '${err.path.join(".")}'` : ""}: ${err.message || "Invalid value"}`.trim();
+	}).join("\n  ");
+}
+/**
+* ProfileManager - handles loading, saving, and managing CLI profiles
+*
+* Profiles are stored in ~/.inkeep/profiles.yaml and allow users to switch
+* between different Inkeep deployments (cloud, local, self-hosted).
+*/
+var ProfileManager = class {
+	profilesDir;
+	profilesPath;
+	constructor(options) {
+		this.profilesDir = options?.profilesDir ?? join(homedir(), ".inkeep");
+		this.profilesPath = join(this.profilesDir, "profiles.yaml");
+	}
+	/**
+	* Get the path to the profiles.yaml file
+	* Creates the ~/.inkeep directory if it doesn't exist
+	*/
+	getProfilePath() {
+		if (!existsSync(this.profilesDir)) {
+			logger.info({ dir: this.profilesDir }, "Creating profiles directory");
+			mkdirSync(this.profilesDir, { recursive: true });
+		}
+		return this.profilesPath;
+	}
+	/**
+	* Check if the profiles file exists
+	*/
+	profilesFileExists() {
+		return existsSync(this.profilesPath);
+	}
+	/**
+	* Load and validate profiles from YAML file
+	* Creates default config if file doesn't exist
+	*/
+	loadProfiles() {
+		const profilePath = this.getProfilePath();
+		if (!existsSync(profilePath)) {
+			logger.info({}, "Profiles file not found, creating default");
+			this.saveProfiles(DEFAULT_PROFILES_CONFIG);
+			return DEFAULT_PROFILES_CONFIG;
+		}
+		let content;
+		try {
+			content = readFileSync(profilePath, "utf-8");
+		} catch (error) {
+			throw new ProfileError(`Failed to read profiles file: ${profilePath}\n${error instanceof Error ? error.message : String(error)}`, "FILE_NOT_FOUND");
+		}
+		let parsed;
+		try {
+			parsed = yaml.parse(content);
+		} catch (error) {
+			throw new ProfileError(`Failed to parse profiles.yaml: ${error instanceof Error ? error.message : String(error)}`, "PARSE_ERROR");
+		}
+		const result = profilesConfigSchema.safeParse(parsed);
+		if (!result.success) throw new ProfileError(`Invalid profiles.yaml:\n  ${formatZodErrors(result.error)}`, "VALIDATION_ERROR");
+		const config = result.data;
+		if (!config.profiles[config.activeProfile]) throw new ProfileError(`Active profile '${config.activeProfile}' does not exist in profiles`, "VALIDATION_ERROR");
+		logger.info({ activeProfile: config.activeProfile }, "Profiles loaded");
+		return config;
+	}
+	/**
+	* Save profiles to YAML file atomically (write to temp, then rename)
+	*/
+	saveProfiles(profiles) {
+		const result = profilesConfigSchema.safeParse(profiles);
+		if (!result.success) throw new ProfileError(`Invalid profiles configuration:\n  ${formatZodErrors(result.error)}`, "VALIDATION_ERROR");
+		if (!profiles.profiles[profiles.activeProfile]) throw new ProfileError(`Active profile '${profiles.activeProfile}' does not exist in profiles`, "VALIDATION_ERROR");
+		const profilePath = this.getProfilePath();
+		const tempPath = join(tmpdir(), `inkeep-profiles-${Date.now()}.yaml`);
+		const yamlContent = yaml.stringify(profiles, {
+			indent: 2,
+			lineWidth: 0
+		});
+		try {
+			writeFileSync(tempPath, yamlContent, "utf-8");
+			renameSync(tempPath, profilePath);
+			logger.info({ path: profilePath }, "Profiles saved");
+		} catch (error) {
+			try {
+				if (existsSync(tempPath)) __require("node:fs").unlinkSync(tempPath);
+			} catch {}
+			throw new ProfileError(`Failed to save profiles: ${error instanceof Error ? error.message : String(error)}`, "WRITE_ERROR");
+		}
+	}
+	/**
+	* Get the currently active profile configuration
+	*/
+	getActiveProfile() {
+		const config = this.loadProfiles();
+		const profileName = config.activeProfile;
+		const profile = config.profiles[profileName];
+		if (!profile) throw new ProfileError(`Active profile '${profileName}' not found in profiles`, "PROFILE_NOT_FOUND");
+		return {
+			name: profileName,
+			remote: this.resolveRemoteUrls(profile),
+			credential: profile.credential,
+			environment: profile.environment
+		};
+	}
+	/**
+	* Resolve remote URLs from profile configuration
+	* If remote is 'cloud', returns baked-in cloud URLs
+	* Otherwise returns the explicit URLs
+	*/
+	resolveRemoteUrls(profile) {
+		if (profile.remote === "cloud") return { ...CLOUD_REMOTE };
+		return { ...profile.remote };
+	}
+	/**
+	* Get a specific profile by name
+	*/
+	getProfile(name) {
+		const profile = this.loadProfiles().profiles[name];
+		if (!profile) return null;
+		return {
+			name,
+			remote: this.resolveRemoteUrls(profile),
+			credential: profile.credential,
+			environment: profile.environment
+		};
+	}
+	/**
+	* List all profiles with their resolved URLs
+	*/
+	listProfiles() {
+		const config = this.loadProfiles();
+		return {
+			profiles: Object.entries(config.profiles).map(([name, profile]) => ({
+				name,
+				remote: this.resolveRemoteUrls(profile),
+				credential: profile.credential,
+				environment: profile.environment
+			})),
+			activeProfile: config.activeProfile
+		};
+	}
+	/**
+	* Add a new profile
+	*/
+	addProfile(name, profile) {
+		const nameResult = profileNameSchema.safeParse(name);
+		if (!nameResult.success) throw new ProfileError(`Invalid profile name: ${formatZodErrors(nameResult.error)}`, "VALIDATION_ERROR");
+		const config = this.loadProfiles();
+		if (config.profiles[name]) throw new ProfileError(`Profile '${name}' already exists`, "PROFILE_EXISTS");
+		config.profiles[name] = profile;
+		this.saveProfiles(config);
+		logger.info({ name }, "Profile added");
+	}
+	/**
+	* Set the active profile
+	*/
+	setActiveProfile(name) {
+		const config = this.loadProfiles();
+		if (!config.profiles[name]) throw new ProfileError(`Profile '${name}' does not exist`, "PROFILE_NOT_FOUND");
+		config.activeProfile = name;
+		this.saveProfiles(config);
+		logger.info({ name }, "Active profile set");
+	}
+	/**
+	* Remove a profile
+	* Cannot remove the currently active profile
+	*/
+	removeProfile(name) {
+		const config = this.loadProfiles();
+		if (!config.profiles[name]) throw new ProfileError(`Profile '${name}' does not exist`, "PROFILE_NOT_FOUND");
+		if (config.activeProfile === name) throw new ProfileError(`Cannot remove active profile '${name}'. Switch to a different profile first.`, "ACTIVE_PROFILE_DELETE");
+		delete config.profiles[name];
+		this.saveProfiles(config);
+		logger.info({ name }, "Profile removed");
+	}
+	/**
+	* Check if a credential reference exists in the keychain
+	* Returns true if it exists, false otherwise
+	* This is a warning check - missing credentials don't block operations
+	*/
+	async checkCredentialExists(credentialRef) {
+		try {
+			const { KeyChainStore } = await import("@inkeep/agents-core/credential-stores");
+			return await new KeyChainStore("auth", "inkeep-cli").get(credentialRef) !== null;
+		} catch {
+			return false;
+		}
+	}
+};
+const profileManager = new ProfileManager();
+
+//#endregion
+export { ProfileError, ProfileManager, profileManager };