@inkeep/agents-cli 0.39.4 → 0.40.0

package/dist/_virtual/rolldown_runtime.js

@@ -0,0 +1,7 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __require };

package/dist/api.js

@@ -0,0 +1,185 @@
+import { OPENAI_MODELS, apiFetch } from "@inkeep/agents-core";
+
+//#region src/api.ts
+var BaseApiClient = class {
+	apiUrl;
+	tenantId;
+	projectId;
+	apiKey;
+	isCI;
+	constructor(apiUrl, tenantId, projectId, apiKey, isCI = false) {
+		this.apiUrl = apiUrl;
+		this.tenantId = tenantId;
+		this.projectId = projectId;
+		this.apiKey = apiKey;
+		this.isCI = isCI;
+	}
+	checkTenantId() {
+		if (!this.tenantId) throw new Error("No tenant ID configured. Please run: inkeep init");
+		return this.tenantId;
+	}
+	/**
+	* Wrapper around fetch that automatically includes auth header
+	* Uses X-API-Key for CI mode, Authorization Bearer for interactive mode
+	*/
+	async authenticatedFetch(url, options = {}) {
+		const headers = { ...options.headers || {} };
+		if (this.apiKey) if (this.isCI) headers["X-API-Key"] = this.apiKey;
+		else headers.Authorization = `Bearer ${this.apiKey}`;
+		return apiFetch(url, {
+			...options,
+			headers
+		});
+	}
+	getTenantId() {
+		return this.tenantId;
+	}
+	getProjectId() {
+		return this.projectId;
+	}
+	getApiUrl() {
+		return this.apiUrl;
+	}
+	getIsCI() {
+		return this.isCI;
+	}
+};
+var ManagementApiClient = class ManagementApiClient extends BaseApiClient {
+	constructor(apiUrl, tenantId, projectId, apiKey, isCI = false) {
+		super(apiUrl, tenantId, projectId, apiKey, isCI);
+	}
+	static async create(apiUrl, configPath, tenantIdOverride, projectIdOverride, isCI, apiKeyOverride) {
+		const { validateConfiguration } = await import("./utils/config.js");
+		const config = await validateConfiguration(configPath);
+		return new ManagementApiClient(apiUrl || config.agentsManageApiUrl, tenantIdOverride || config.tenantId, projectIdOverride || "", apiKeyOverride || config.agentsManageApiKey, isCI ?? false);
+	}
+	async listAgents() {
+		const tenantId = this.checkTenantId();
+		const projectId = this.getProjectId();
+		const response = await this.authenticatedFetch(`${this.apiUrl}/tenants/${tenantId}/projects/${projectId}/agents?limit=100`, { method: "GET" });
+		if (!response.ok) throw new Error(`Failed to list agents: ${response.statusText}. ${this.apiUrl}/tenants/${tenantId}/projects/${projectId}/agents`);
+		return (await response.json()).data || [];
+	}
+	async getAgent(agentId) {
+		return (await this.listAgents()).find((g) => g.id === agentId) || null;
+	}
+	async pushAgent(agentDefinition) {
+		const tenantId = this.checkTenantId();
+		const projectId = this.getProjectId();
+		const agentId = agentDefinition.id;
+		if (!agentId) throw new Error("Agent must have an id property");
+		const response = await this.authenticatedFetch(`${this.apiUrl}/tenants/${tenantId}/projects/${projectId}/agents/${agentId}`, {
+			method: "PUT",
+			body: JSON.stringify({
+				...agentDefinition,
+				tenantId
+			})
+		});
+		if (!response.ok) {
+			const errorText = await response.text();
+			throw new Error(`Failed to push agent: ${response.statusText}\n${errorText}`);
+		}
+		return (await response.json()).data;
+	}
+	async getFullProject(projectId) {
+		const tenantId = this.checkTenantId();
+		const response = await this.authenticatedFetch(`${this.apiUrl}/tenants/${tenantId}/project-full/${projectId}`, { method: "GET" });
+		if (!response.ok) {
+			if (response.status === 404) throw new Error(`Project "${projectId}" not found`);
+			if (response.status === 401 || response.status === 403) {
+				const errorText$1 = await response.text().catch(() => "");
+				let errorMessage = "Authentication failed - check your API key configuration\n\n";
+				errorMessage += "Common issues:\n";
+				errorMessage += "  • Missing or invalid API key in inkeep.config.ts\n";
+				errorMessage += "  • API key does not have access to this tenant/project\n";
+				errorMessage += "  • For local development, ensure INKEEP_AGENTS_MANAGE_API_BYPASS_SECRET is set\n";
+				if (errorText$1) errorMessage += `\nServer response: ${errorText$1}`;
+				throw new Error(errorMessage);
+			}
+			const errorText = await response.text().catch(() => "");
+			throw new Error(`Failed to fetch project: ${response.statusText}${errorText ? `\n${errorText}` : ""}`);
+		}
+		return (await response.json()).data;
+	}
+	/**
+	* List all projects for the current tenant
+	* @param page - Page number (1-based)
+	* @param limit - Number of results per page (max 100)
+	* @returns List of projects with pagination info
+	*/
+	async listProjects(page = 1, limit = 100) {
+		const tenantId = this.checkTenantId();
+		const response = await this.authenticatedFetch(`${this.apiUrl}/tenants/${tenantId}/projects?page=${page}&limit=${limit}`, { method: "GET" });
+		if (!response.ok) {
+			if (response.status === 401 || response.status === 403) {
+				const errorText$1 = await response.text().catch(() => "");
+				let errorMessage = "Authentication failed - check your API key configuration\n\n";
+				errorMessage += "Common issues:\n";
+				errorMessage += "  • Missing or invalid API key in inkeep.config.ts\n";
+				errorMessage += "  • API key does not have access to this tenant\n";
+				if (errorText$1) errorMessage += `\nServer response: ${errorText$1}`;
+				throw new Error(errorMessage);
+			}
+			const errorText = await response.text().catch(() => "");
+			throw new Error(`Failed to list projects: ${response.statusText}${errorText ? `\n${errorText}` : ""}`);
+		}
+		return await response.json();
+	}
+	/**
+	* List all projects for the current tenant (fetches all pages)
+	* @returns Array of all projects
+	*/
+	async listAllProjects() {
+		const allProjects = [];
+		let page = 1;
+		const limit = 100;
+		while (true) {
+			const result = await this.listProjects(page, limit);
+			allProjects.push(...result.data);
+			if (result.data.length < limit || allProjects.length >= result.pagination.total) break;
+			page++;
+		}
+		return allProjects;
+	}
+};
+var ExecutionApiClient = class ExecutionApiClient extends BaseApiClient {
+	constructor(apiUrl, tenantId, projectId, apiKey, isCI = false) {
+		super(apiUrl, tenantId, projectId, apiKey, isCI);
+	}
+	static async create(apiUrl, configPath, tenantIdOverride, projectIdOverride, isCI) {
+		const { validateConfiguration } = await import("./utils/config.js");
+		const config = await validateConfiguration(configPath);
+		return new ExecutionApiClient(apiUrl || config.agentsRunApiUrl, tenantIdOverride || config.tenantId, projectIdOverride || "", config.agentsRunApiKey, isCI ?? false);
+	}
+	async chatCompletion(agentId, messages, conversationId, emitOperations) {
+		const response = await this.authenticatedFetch(`${this.apiUrl}/v1/chat/completions`, {
+			method: "POST",
+			headers: {
+				Accept: "text/event-stream",
+				"x-inkeep-tenant-id": this.tenantId || "test-tenant-id",
+				"x-inkeep-project-id": this.projectId,
+				"x-inkeep-agent-id": agentId,
+				...emitOperations && { "x-emit-operations": "true" }
+			},
+			body: JSON.stringify({
+				model: OPENAI_MODELS.GPT_4_1_MINI,
+				messages,
+				conversationId,
+				stream: true
+			})
+		});
+		if (!response.ok) {
+			const errorText = await response.text();
+			throw new Error(`Chat request failed: ${response.statusText}\n${errorText}`);
+		}
+		if (response.headers.get("content-type")?.includes("text/event-stream")) {
+			if (!response.body) throw new Error("No response body for streaming request");
+			return response.body;
+		}
+		const data = await response.json();
+		return data.choices?.[0]?.message?.content || data.result || "";
+	}
+};
+
+//#endregion
+export { ExecutionApiClient, ManagementApiClient };

package/dist/commands/add.js

@@ -0,0 +1,139 @@
+import { cloneTemplate, cloneTemplateLocal, getAvailableTemplates } from "../utils/templates.js";
+import { ANTHROPIC_MODELS, GOOGLE_MODELS, OPENAI_MODELS } from "@inkeep/agents-core";
+import path from "node:path";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { findUp } from "find-up";
+import fs from "fs-extra";
+
+//#region src/commands/add.ts
+const defaultGoogleModelConfigurations = {
+	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 }
+};
+async function addCommand(options) {
+	const projectTemplates = await getAvailableTemplates("template-projects", options.localPrefix);
+	const mcpTemplates = await getAvailableTemplates("template-mcps", options.localPrefix);
+	if (!options.project && !options.mcp) {
+		console.log(chalk.cyan("\nUsage:\n"));
+		console.log(chalk.white("Add a project with: inkeep add --project <project-template>"));
+		console.log(chalk.gray("  Example: inkeep add --project docs-assistant\n"));
+		console.log(chalk.yellow("Available project templates:"));
+		for (const template of projectTemplates) console.log(chalk.gray(`  • ${template}`));
+		console.log(chalk.white("\nAdd an MCP server with: inkeep add --mcp <mcp-template>"));
+		console.log(chalk.gray("  Example: inkeep add --mcp slack\n"));
+		console.log(chalk.yellow("Available MCP templates:"));
+		for (const template of mcpTemplates) console.log(chalk.gray(`  • ${template}`));
+		process.exit(0);
+	} else {
+		if (options.project && !projectTemplates.includes(options.project)) {
+			console.error(`❌ Project template "${options.project}" not found`);
+			process.exit(1);
+		}
+		if (options.mcp && !mcpTemplates.includes(options.mcp)) {
+			console.error(`❌ MCP template "${options.mcp}" not found`);
+			process.exit(1);
+		}
+		if (options.project) await addProjectTemplate(projectTemplates, options.project, options.targetPath, options.localPrefix);
+		if (options.mcp) await addMcpTemplate(mcpTemplates, options.mcp, options.targetPath, options.localPrefix);
+		return;
+	}
+}
+async function checkTemplateDir(templateDir, commandType) {
+	const s = p.spinner();
+	if (await fs.pathExists(templateDir)) {
+		if (!await p.confirm({ message: `Directory "${templateDir}" already exists. Do you want to overwrite it?` })) {
+			p.cancel(`You can specify a different target path like: \`inkeep add --${commandType} <${commandType}-template> --target-path <path>\``);
+			process.exit(0);
+		}
+		s.start("Cleaning existing directory...");
+		await fs.emptyDir(templateDir);
+		s.stop();
+	}
+}
+function buildTemplateUrl(templateType, templateName) {
+	return `https://github.com/inkeep/agents/agents-cookbook/${templateType}/${templateName}`;
+}
+async function addProjectTemplate(availableTemplates, template, targetPath, localPrefix) {
+	if (!template) {
+		console.log(chalk.yellow("Available templates:"));
+		for (const template$1 of availableTemplates) console.log(chalk.gray(`  • ${template$1}`));
+		process.exit(0);
+	} else {
+		if (!availableTemplates.includes(template)) {
+			console.error(`❌ Template "${template}" not found`);
+			process.exit(1);
+		}
+		const s = p.spinner();
+		const anthropicKey = process.env.ANTHROPIC_API_KEY;
+		const openAiKey = process.env.OPENAI_API_KEY;
+		const googleKey = process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+		let defaultModelSettings = {};
+		if (anthropicKey) defaultModelSettings = defaultAnthropicModelConfigurations;
+		else if (openAiKey) defaultModelSettings = defaultOpenaiModelConfigurations;
+		else if (googleKey) defaultModelSettings = defaultGoogleModelConfigurations;
+		const contentReplacements = [{
+			filePath: "index.ts",
+			replacements: { models: defaultModelSettings }
+		}];
+		if (Object.keys(defaultModelSettings).length === 0) console.error("❌ No AI provider key found in environment variables. Please set one of: ANTHROPIC_API_KEY, OPENAI_API_KEY, or GOOGLE_GENERATIVE_AI_API_KEY");
+		const projectDirectory = await findAppDirectory("project");
+		const baseDir = targetPath || projectDirectory;
+		const templateDir = path.join(baseDir, template);
+		await checkTemplateDir(templateDir, "project");
+		if (targetPath && !await fs.pathExists(baseDir)) try {
+			await fs.mkdir(baseDir, { recursive: true });
+		} catch (error) {
+			console.error(`❌ Failed to create target directory "${baseDir}": ${error instanceof Error ? error.message : "Unknown error"}`);
+			process.exit(1);
+		}
+		s.start("Adding template...");
+		if (localPrefix && localPrefix.length > 0) await cloneTemplateLocal(path.join(localPrefix, "template-projects", template), templateDir, contentReplacements);
+		else await cloneTemplate(buildTemplateUrl("template-projects", template), templateDir, contentReplacements);
+		s.stop(`Template "${template}" added to ${templateDir}`);
+		return;
+	}
+}
+async function addMcpTemplate(availableTemplates, template, targetPath, localPrefix) {
+	if (!template) {
+		console.log(chalk.yellow("Available templates:"));
+		for (const template$1 of availableTemplates) console.log(chalk.gray(`  • ${template$1}`));
+		process.exit(0);
+	}
+	if (!targetPath) {
+		const foundPath = await findAppDirectory("mcp");
+		targetPath = path.join(foundPath, template);
+	}
+	await checkTemplateDir(targetPath, "mcp");
+	const s = p.spinner();
+	s.start("Adding template...");
+	if (localPrefix && localPrefix.length > 0) await cloneTemplateLocal(path.join(localPrefix, "template-mcps", template), targetPath);
+	else await cloneTemplate(buildTemplateUrl("template-mcps", template), targetPath);
+	s.stop(`MCP template "${template}" added to ${targetPath}`);
+}
+async function findAppDirectory(type) {
+	const searchPath = type === "project" ? "src/projects" : "apps/mcp/app";
+	const directory = await findUp(searchPath, { type: "directory" });
+	if (!directory || !directory.includes(searchPath)) {
+		console.log(chalk.yellow(`⚠️  No ${type} directory found.`));
+		if (!await p.confirm({ message: `Do you want to add to ${process.cwd()} instead?` })) {
+			p.cancel("Operation cancelled");
+			process.exit(0);
+		}
+	}
+	return directory || process.cwd();
+}
+
+//#endregion
+export { addCommand, addMcpTemplate, addProjectTemplate, checkTemplateDir, defaultAnthropicModelConfigurations, defaultGoogleModelConfigurations, defaultOpenaiModelConfigurations, findAppDirectory };

package/dist/commands/config.js

@@ -0,0 +1,86 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+
+//#region src/commands/config.ts
+async function configGetCommand(key, options) {
+	const configPath = options?.config || options?.configFilePath || join(process.cwd(), "inkeep.config.ts");
+	if (!existsSync(configPath)) {
+		console.error(chalk.red("No configuration file found."));
+		console.log(chalk.gray("Run \"inkeep init\" to create one, or specify a config file with --config"));
+		process.exit(1);
+	}
+	try {
+		const content = readFileSync(configPath, "utf-8");
+		const tenantIdMatch = content.match(/tenantId:\s*['"]([^'"]+)['"]/);
+		const apiUrlMatch = content.match(/apiUrl:\s*['"]([^'"]+)['"]/);
+		const config = {
+			tenantId: tenantIdMatch ? tenantIdMatch[1] : void 0,
+			apiUrl: apiUrlMatch ? apiUrlMatch[1] : void 0
+		};
+		if (key) {
+			const value = config[key];
+			if (value !== void 0) console.log(value);
+			else {
+				console.error(chalk.red(`Unknown configuration key: ${key}`));
+				console.log(chalk.gray("Available keys: tenantId, apiUrl"));
+				process.exit(1);
+			}
+		} else {
+			console.log(chalk.cyan("Current configuration:"));
+			console.log(chalk.gray("  Config file:"), configPath);
+			console.log(chalk.gray("  Tenant ID:"), config.tenantId || chalk.yellow("(not set)"));
+			console.log(chalk.gray("  API URL:"), config.apiUrl || chalk.yellow("(not set)"));
+		}
+	} catch (error) {
+		console.error(chalk.red("Failed to read configuration:"), error);
+		process.exit(1);
+	}
+}
+async function configSetCommand(key, value, options) {
+	const configPath = options?.config || options?.configFilePath || join(process.cwd(), "inkeep.config.ts");
+	if (!["tenantId", "apiUrl"].includes(key)) {
+		console.error(chalk.red(`Invalid configuration key: ${key}`));
+		console.log(chalk.gray("Available keys: tenantId, apiUrl"));
+		process.exit(1);
+	}
+	if (key === "apiUrl") try {
+		new URL(value);
+	} catch {
+		console.error(chalk.red("Invalid URL format"));
+		process.exit(1);
+	}
+	if (!existsSync(configPath)) {
+		const configContent = `import { defineConfig } from '@inkeep/agents-cli';
+
+export default defineConfig({
+    tenantId: '${key === "tenantId" ? value : ""}',
+    apiUrl: '${key === "apiUrl" ? value : "http://localhost:3002"}',
+});
+`;
+		try {
+			writeFileSync(configPath, configContent);
+			console.log(chalk.green("✓"), `Created config file and set ${key} to:`, chalk.cyan(value));
+		} catch (error) {
+			console.error(chalk.red("Failed to create config file:"), error);
+			process.exit(1);
+		}
+	} else try {
+		let content = readFileSync(configPath, "utf-8");
+		if (key === "tenantId") if (content.includes("tenantId:")) content = content.replace(/tenantId:\s*['"][^'"]*['"]/, `tenantId: '${value}'`);
+		else content = content.replace(/defineConfig\s*\(\s*{/, `defineConfig({\n    tenantId: '${value}',`);
+		else if (key === "apiUrl") if (content.includes("apiUrl:")) content = content.replace(/apiUrl:\s*['"][^'"]*['"]/, `apiUrl: '${value}'`);
+		else content = content.replace(/defineConfig\s*\(\s*{/, `defineConfig({\n    apiUrl: '${value}',`);
+		writeFileSync(configPath, content);
+		console.log(chalk.green("✓"), `Updated ${key} to:`, chalk.cyan(value));
+	} catch (error) {
+		console.error(chalk.red("Failed to update config file:"), error);
+		process.exit(1);
+	}
+}
+async function configListCommand(options) {
+	await configGetCommand(void 0, options);
+}
+
+//#endregion
+export { configGetCommand, configListCommand, configSetCommand };

package/dist/commands/dev.js

@@ -0,0 +1,259 @@
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import fs from "fs-extra";
+import { fork } from "node:child_process";
+import open from "open";
+
+//#region src/commands/dev.ts
+const require = createRequire(import.meta.url);
+async function waitForServer(host, port, maxAttempts = 60) {
+	for (let i = 0; i < maxAttempts; i++) {
+		try {
+			const response = await fetch(`http://${host}:${port}`, {
+				method: "GET",
+				signal: AbortSignal.timeout(2e3)
+			});
+			if (response.ok) {
+				const text = await response.text();
+				if (text && text.length > 0 && text.includes("<!DOCTYPE html>")) {
+					await new Promise((resolve$1) => setTimeout(resolve$1, 1e3));
+					return true;
+				}
+			}
+		} catch {}
+		await new Promise((resolve$1) => setTimeout(resolve$1, 500));
+	}
+	return false;
+}
+function resolveWebRuntime(isRoot = false) {
+	try {
+		const root = dirname(require.resolve("@inkeep/agents-manage-ui/package.json"));
+		if (isRoot) return root;
+		return join(root, ".next/standalone/agents-manage-ui");
+	} catch (err) {
+		throw new Error(`Could not find @inkeep/agents-manage-ui package. Please install it first:
+
+  npm install @inkeep/agents-manage-ui
+  # or
+  pnpm add @inkeep/agents-manage-ui
+
+Error: ${err instanceof Error ? err.message : "Unknown error"}`);
+	}
+}
+async function startWebApp({ port, host, openBrowser }) {
+	console.log("");
+	const s = p.spinner();
+	s.start("Starting dashboard server...");
+	try {
+		const rt = resolveWebRuntime();
+		const entry = join(rt, "server.js");
+		if (!existsSync(entry)) {
+			s.stop("Dashboard server not found");
+			console.error(chalk.red("The dashboard server has not been built yet."));
+			process.exit(1);
+		}
+		s.stop("Starting dashboard server...");
+		console.log("");
+		const child = fork(entry, [], {
+			cwd: rt,
+			env: {
+				...process.env,
+				NODE_ENV: "production",
+				PORT: String(port),
+				HOSTNAME: host
+			},
+			stdio: "inherit"
+		});
+		console.log(chalk.green(`🚀 Dashboard server started at http://${host}:${port}`));
+		console.log("");
+		console.log(chalk.gray("Press Ctrl+C to stop the server"));
+		console.log("");
+		if (openBrowser) {
+			console.log(chalk.gray("Waiting for server to be ready..."));
+			if (await waitForServer(host, port)) await open(`http://${host}:${port}`);
+			else {
+				console.log(chalk.yellow("⚠️  Server did not respond in time, skipping browser open"));
+				console.log(chalk.gray(`   You can manually open: http://${host}:${port}`));
+			}
+		}
+		process.on("SIGINT", () => {
+			console.log("");
+			console.log(chalk.yellow("\n🛑 Stopping dashboard server..."));
+			child.kill("SIGINT");
+			process.exit(0);
+		});
+		process.on("SIGTERM", () => {
+			child.kill("SIGTERM");
+			process.exit(0);
+		});
+		return child;
+	} catch (error) {
+		s.stop("Failed to start dashboard server");
+		console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+		process.exit(1);
+	}
+}
+async function buildNextApp({ outputDir }) {
+	console.log("");
+	const s = p.spinner();
+	s.start("Building Standalone build...");
+	try {
+		const standalonePath = join(dirname(require.resolve("@inkeep/agents-manage-ui/package.json")), ".next/standalone/agents-manage-ui");
+		if (!existsSync(standalonePath)) {
+			s.stop("Standalone build not found");
+			console.error(chalk.red("The standalone build has not been created yet."));
+			console.error(chalk.yellow("Please build the dashboard first:"));
+			console.error(chalk.gray("  cd node_modules/@inkeep/agents-manage-ui"));
+			console.error(chalk.gray("  npm run build"));
+			process.exit(1);
+		}
+		if (existsSync(outputDir)) await fs.remove(outputDir);
+		if (existsSync(outputDir)) await fs.remove(outputDir);
+		await fs.ensureDir(outputDir);
+		await fs.copy(standalonePath, outputDir);
+		await fs.writeJson(join(outputDir, "package.json"), {
+			name: "inkeep-dashboard",
+			version: "1.0.0",
+			scripts: { start: "node server.js" },
+			dependencies: {}
+		}, { spaces: 2 });
+		await fs.writeFile(join(outputDir, "README.md"), `
+## Environment Variables
+
+Make sure to set these in your Vercel project settings:
+- INKEEP_API_URL
+- INKEEP_TENANT_ID
+- Any other variables from your .env file
+`);
+		s.stop(`Build created at ${outputDir}/`);
+		console.log("");
+		console.log(chalk.green("✅ Build completed successfully!"));
+		console.log("");
+		console.log(chalk.blue("📁 To run your dashboard:"));
+		console.log(chalk.gray("  cd"), chalk.white(outputDir));
+		console.log(chalk.gray("  npm start"));
+		console.log("");
+		console.log(chalk.blue("🌐 Or with pnpm:"));
+		console.log(chalk.gray("  cd"), chalk.white(outputDir));
+		console.log(chalk.gray("  pnpm start"));
+		console.log("");
+		console.log(chalk.yellow("📖 See README.md for deployment instructions"));
+		console.log("");
+	} catch (error) {
+		s.stop("Failed to build dashboard");
+		console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+		throw error;
+	}
+}
+async function exportNextApp({ outputDir }) {
+	console.log("");
+	const s = p.spinner();
+	s.start("Exporting Next.js project...");
+	try {
+		const root = dirname(require.resolve("@inkeep/agents-manage-ui/package.json"));
+		if (!existsSync(root)) {
+			s.stop("Source project not found");
+			console.error(chalk.red("The @inkeep/agents-manage-ui package was not found."));
+			console.error(chalk.yellow("Please install it first:"));
+			console.error(chalk.gray("  npm install @inkeep/agents-manage-ui"));
+			console.error(chalk.gray("  # or"));
+			console.error(chalk.gray("  pnpm add @inkeep/agents-manage-ui"));
+			process.exit(1);
+		}
+		if (existsSync(outputDir)) await fs.remove(outputDir);
+		await fs.ensureDir(outputDir);
+		const items = await fs.readdir(root);
+		for (const item of items) {
+			const srcPath = join(root, item);
+			const destPath = join(outputDir, item);
+			if (item === ".next" || item === "node_modules" || item === "dist") continue;
+			if ((await fs.stat(srcPath)).isDirectory()) await fs.copy(srcPath, destPath);
+			else await fs.copy(srcPath, destPath);
+		}
+		await fs.writeFile(join(outputDir, "README.md"), `# Inkeep Dashboard
+
+This is an exported copy of the Inkeep Dashboard UI.
+
+## Getting Started
+
+1. Install dependencies:
+   \`\`\`bash
+   npm install
+   # or
+   pnpm install
+   \`\`\`
+
+2. Start the development server:
+   \`\`\`bash
+   npm run dev
+   # or
+   pnpm dev
+   \`\`\`
+
+3. Build for production:
+   \`\`\`bash
+   npm run build
+   # or
+   pnpm build
+   \`\`\`
+
+## Environment Variables
+
+Make sure to set these environment variables:
+- \`INKEEP_API_URL\` - Your Inkeep API URL
+- \`INKEEP_TENANT_ID\` - Your tenant ID
+- Any other variables from your .env file
+
+## Deployment
+
+This project can be deployed to any platform that supports Next.js:
+- Vercel
+- Netlify
+- AWS Amplify
+- Railway
+- And more...
+`);
+		s.stop(`Project exported to ${outputDir}/`);
+		console.log("");
+		console.log(chalk.green("✅ Export completed successfully!"));
+		console.log("");
+		console.log(chalk.blue("📁 To get started:"));
+		console.log(chalk.gray("  cd"), chalk.white(outputDir));
+		console.log(chalk.gray("  npm install"));
+		console.log(chalk.gray("  npm run dev"));
+		console.log("");
+		console.log(chalk.yellow("📖 See README.md for more instructions"));
+		console.log("");
+	} catch (error) {
+		s.stop("Failed to export project");
+		console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+		throw error;
+	}
+}
+async function devCommand(options) {
+	const { port, host, build, outputDir, path: path$1, export: exportFlag, openBrowser } = options;
+	if (path$1) {
+		const rt = resolveWebRuntime(true);
+		console.log(rt);
+		return;
+	}
+	if (exportFlag) {
+		await exportNextApp({ outputDir });
+		return;
+	}
+	if (build) {
+		await buildNextApp({ outputDir });
+		return;
+	}
+	await startWebApp({
+		port,
+		host,
+		openBrowser
+	});
+}
+
+//#endregion
+export { devCommand };