@jive-ai/cli 0.0.1

package/dist/index.mjs

@@ -0,0 +1,2292 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import prompts from "prompts";
+import chalk from "chalk";
+import ora from "ora";
+import axios from "axios";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import "crypto";
+import matter from "gray-matter";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import * as ts from "typescript";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import fs$1 from "fs";
+import { fileURLToPath } from "url";
+
+//#region src/lib/config.ts
+const CREDENTIALS_PATH = path.join(os.homedir(), ".jive", "credentials.json");
+const PROJECT_CONFIG_PATH = path.join(process.cwd(), ".jive", "config.json");
+const SYNC_STATE_PATH = path.join(process.cwd(), ".jive", "sync.json");
+async function ensureDir(filePath) {
+	const dir = path.dirname(filePath);
+	try {
+		await fs.access(dir);
+	} catch {
+		await fs.mkdir(dir, {
+			recursive: true,
+			mode: 448
+		});
+	}
+}
+async function getCredentials() {
+	try {
+		const data = await fs.readFile(CREDENTIALS_PATH, "utf-8");
+		return JSON.parse(data);
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+async function saveCredentials(credentials) {
+	await ensureDir(CREDENTIALS_PATH);
+	await fs.writeFile(CREDENTIALS_PATH, JSON.stringify(credentials, null, 2), { mode: 384 });
+}
+async function clearCredentials() {
+	try {
+		await fs.unlink(CREDENTIALS_PATH);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+async function requireAuth() {
+	const credentials = await getCredentials();
+	if (!credentials) {
+		console.error(chalk.red("Not authenticated. Please run `jive login` first."));
+		process.exit(1);
+	}
+	return credentials;
+}
+async function getProjectConfig() {
+	try {
+		const data = await fs.readFile(PROJECT_CONFIG_PATH, "utf-8");
+		return JSON.parse(data);
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+async function saveProjectConfig(config) {
+	await ensureDir(PROJECT_CONFIG_PATH);
+	await fs.writeFile(PROJECT_CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+async function updateProjectConfig(updates) {
+	const config = await getProjectConfig();
+	if (!config) throw new Error("Project not initialized. Run `jive init` first.");
+	await saveProjectConfig({
+		...config,
+		...updates
+	});
+}
+async function requireProjectConfig() {
+	const config = await getProjectConfig();
+	if (!config) {
+		console.error(chalk.red("Project not initialized. Please run `jive init` first."));
+		process.exit(1);
+	}
+	return config;
+}
+async function getActiveTeamId() {
+	const config = await requireProjectConfig();
+	return config.activeTeamId || config.teamId;
+}
+async function isProjectInitialized() {
+	return await getProjectConfig() !== null;
+}
+
+//#endregion
+//#region src/lib/api-client.ts
+var ApiClient = class {
+	client;
+	baseURL;
+	constructor(baseURL) {
+		this.baseURL = baseURL || process.env.JIVE_API_URL || "https://next.getjive.app";
+		this.client = axios.create({
+			baseURL: this.baseURL,
+			timeout: 3e4,
+			headers: { "Content-Type": "application/json" }
+		});
+		this.client.interceptors.request.use(async (config) => {
+			const credentials = await getCredentials();
+			if (credentials?.token) config.headers["X-API-Key"] = credentials.token;
+			return config;
+		}, (error) => Promise.reject(error));
+		this.client.interceptors.response.use((response) => response, async (error) => {
+			if (error.response?.status === 401) {
+				console.error(chalk.red("Authentication failed. Please run `jive login` again."));
+				process.exit(1);
+			}
+			return Promise.reject(this.formatError(error));
+		});
+	}
+	formatError(error) {
+		if (error.response) return {
+			message: error.response.data?.message || error.message,
+			status: error.response.status,
+			details: error.response.data
+		};
+		else if (error.request) return { message: `Unable to connect to ${this.baseURL}. Please check your internet connection.` };
+		else return { message: error.message };
+	}
+	async signup(email, password) {
+		return (await this.client.post("/api/auth/signup", {
+			email,
+			password
+		})).data;
+	}
+	async login(email, password) {
+		return (await this.client.post("/api/auth/login", {
+			email,
+			password
+		})).data;
+	}
+	async logout() {
+		await this.client.post("/api/auth/logout");
+	}
+	async getTeams() {
+		return (await this.client.get("/api/teams")).data;
+	}
+	async createTeam(name, description) {
+		return (await this.client.post("/api/teams", {
+			name,
+			description
+		})).data;
+	}
+	async inviteToTeam(teamId, email) {
+		await this.client.post(`/api/teams/${teamId}/invite`, { email });
+	}
+	async getSubagents(teamId) {
+		return (await this.client.get(`/api/teams/${teamId}/subagents`)).data;
+	}
+	async createSubagent(teamId, data) {
+		return (await this.client.post(`/api/teams/${teamId}/subagents`, data)).data;
+	}
+	async updateSubagent(id, data) {
+		return (await this.client.put(`/api/subagents/${id}`, data)).data;
+	}
+	async deleteSubagent(id) {
+		await this.client.delete(`/api/subagents/${id}`);
+	}
+	async getMcpServers(teamId) {
+		return (await this.client.get(`/api/teams/${teamId}/mcp-servers`)).data;
+	}
+	async createMcpServer(teamId, data) {
+		return (await this.client.post(`/api/teams/${teamId}/mcp-servers`, data)).data;
+	}
+	async updateMcpServer(id, data) {
+		return (await this.client.put(`/api/mcp-servers/${id}`, data)).data;
+	}
+	async deleteMcpServer(id) {
+		await this.client.delete(`/api/mcp-servers/${id}`);
+	}
+};
+let apiClient = null;
+function getApiClient() {
+	if (!apiClient) apiClient = new ApiClient();
+	return apiClient;
+}
+
+//#endregion
+//#region src/commands/auth.ts
+async function signupCommand() {
+	console.log(chalk.bold("\n🚀 Create Your Jive Account\n"));
+	const response = await prompts([
+		{
+			type: "text",
+			name: "email",
+			message: "Email address:",
+			validate: (value) => {
+				if (!value) return "Email is required";
+				if (!value.includes("@")) return "Please enter a valid email";
+				return true;
+			}
+		},
+		{
+			type: "password",
+			name: "password",
+			message: "Password (min 8 characters):",
+			validate: (value) => {
+				if (!value) return "Password is required";
+				if (value.length < 8) return "Password must be at least 8 characters";
+				return true;
+			}
+		},
+		{
+			type: "password",
+			name: "confirmPassword",
+			message: "Confirm password:",
+			validate: (value, prev) => {
+				if (value !== prev.password) return "Passwords do not match";
+				return true;
+			}
+		}
+	]);
+	if (!response.email || !response.password) {
+		console.log(chalk.yellow("\n❌ Signup cancelled"));
+		return;
+	}
+	const spinner = ora("Creating account...").start();
+	try {
+		const result = await getApiClient().signup(response.email, response.password);
+		spinner.succeed(chalk.green("Account created successfully!"));
+		console.log(chalk.cyan(`\n📧 Logged in as: ${result.email}`));
+		console.log(chalk.gray(`\n${result.message || "Next, create or join a team to get started."}`));
+		console.log(chalk.white("\nRun"), chalk.cyan("jive team create"), chalk.white("to create a team"));
+		console.log(chalk.white("Or"), chalk.cyan("jive init"), chalk.white("to initialize your project with an existing team\n"));
+		await saveCredentials({
+			token: result.token,
+			userId: result.userId,
+			email: result.email
+		});
+	} catch (error) {
+		spinner.fail(chalk.red("Signup failed"));
+		console.error(chalk.red(`\n❌ ${error.message || "An error occurred"}`));
+		if (error.details) console.error(chalk.gray(JSON.stringify(error.details, null, 2)));
+		process.exit(1);
+	}
+}
+async function loginCommand() {
+	console.log(chalk.bold("\n👋 Login to Jive\n"));
+	const response = await prompts([{
+		type: "text",
+		name: "email",
+		message: "Email address:",
+		validate: (value) => value ? true : "Email is required"
+	}, {
+		type: "password",
+		name: "password",
+		message: "Password:",
+		validate: (value) => value ? true : "Password is required"
+	}]);
+	if (!response.email || !response.password) {
+		console.log(chalk.yellow("\n❌ Login cancelled"));
+		return;
+	}
+	const spinner = ora("Logging in...").start();
+	try {
+		const result = await getApiClient().login(response.email, response.password);
+		spinner.succeed(chalk.green("Logged in successfully!"));
+		console.log(chalk.cyan(`\n📧 ${result.email}`));
+		console.log(chalk.green("✓ API key configured\n"));
+		await saveCredentials({
+			token: result.token,
+			userId: result.userId,
+			email: result.email
+		});
+		console.log(chalk.white("Next steps:"));
+		console.log(chalk.white("  • Run"), chalk.cyan("jive team create"), chalk.white("to create a team"));
+		console.log(chalk.white("  • Run"), chalk.cyan("jive init"), chalk.white("to initialize your project with an existing team\n"));
+	} catch (error) {
+		spinner.fail(chalk.red("Login failed"));
+		console.error(chalk.red(`\n❌ ${error.message || "Invalid email or password"}`));
+		process.exit(1);
+	}
+}
+async function logoutCommand() {
+	const credentials = await getCredentials();
+	if (!credentials) {
+		console.log(chalk.yellow("\n⚠️  You are not logged in"));
+		return;
+	}
+	if (!(await prompts({
+		type: "confirm",
+		name: "confirm",
+		message: `Logout from ${credentials.email}?`,
+		initial: true
+	})).confirm) {
+		console.log(chalk.yellow("\n❌ Logout cancelled"));
+		return;
+	}
+	await clearCredentials();
+	console.log(chalk.green("\n✅ Logged out successfully"));
+	console.log(chalk.gray(`Run ${chalk.cyan("jive login")} to login again\n`));
+}
+
+//#endregion
+//#region src/commands/team.ts
+const teamCommands = {
+	async create() {
+		await requireAuth();
+		console.log(chalk.bold("\n🎉 Create a New Team\n"));
+		const response = await prompts([{
+			type: "text",
+			name: "name",
+			message: "Team name:",
+			validate: (value) => {
+				if (!value) return "Team name is required";
+				if (value.length < 3) return "Team name must be at least 3 characters";
+				return true;
+			}
+		}, {
+			type: "text",
+			name: "description",
+			message: "Description (optional):"
+		}]);
+		if (!response.name) {
+			console.log(chalk.yellow("\n❌ Team creation cancelled"));
+			return;
+		}
+		const spinner = ora("Creating team...").start();
+		try {
+			const result = await getApiClient().createTeam(response.name, response.description);
+			spinner.succeed(chalk.green("Team created successfully!"));
+			console.log(chalk.cyan(`\n✨ Team: ${result.name}`));
+			console.log(chalk.gray(`   ID: ${result.id}`));
+			if (result.token) {
+				const credentials = await import("./config-BP7v03In.mjs").then((m) => m.getCredentials());
+				if (credentials) await saveCredentials({
+					...credentials,
+					token: result.token
+				});
+				console.log(chalk.green("\n✓ New API key configured"));
+			}
+			console.log(chalk.white("\nNext step:"));
+			console.log(chalk.white("  Run"), chalk.cyan("jive init"), chalk.white("in your project to get started\n"));
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to create team"));
+			console.error(chalk.red(`\n❌ ${error.message || "An error occurred"}`));
+			process.exit(1);
+		}
+	},
+	async list() {
+		await requireAuth();
+		const spinner = ora("Fetching teams...").start();
+		try {
+			const result = await getApiClient().getTeams();
+			spinner.stop();
+			if (result.teams.length === 0) {
+				console.log(chalk.yellow("\n⚠️  You are not a member of any teams"));
+				console.log(chalk.white("Run"), chalk.cyan("jive team create"), chalk.white("to create a team\n"));
+				return;
+			}
+			console.log(chalk.bold("\n📋 Your Teams:\n"));
+			let activeTeamId = null;
+			try {
+				activeTeamId = await getActiveTeamId();
+			} catch {}
+			for (const team$1 of result.teams) {
+				const isActive = activeTeamId === team$1.id.toString();
+				const marker = isActive ? chalk.green("* ") : "  ";
+				const name = isActive ? chalk.green.bold(team$1.name) : chalk.white(team$1.name);
+				const suffix = isActive ? chalk.gray(" (active)") : "";
+				console.log(`${marker}${name}${suffix}`);
+				console.log(chalk.gray(`  ID: ${team$1.id}`));
+			}
+			console.log();
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to fetch teams"));
+			console.error(chalk.red(`\n❌ ${error.message || "An error occurred"}`));
+			process.exit(1);
+		}
+	},
+	async switch() {
+		await requireAuth();
+		const spinner = ora("Fetching teams...").start();
+		try {
+			const result = await getApiClient().getTeams();
+			spinner.stop();
+			if (result.teams.length === 0) {
+				console.log(chalk.yellow("\n⚠️  You are not a member of any teams"));
+				console.log(chalk.white("Run"), chalk.cyan("jive team create"), chalk.white("to create a team\n"));
+				return;
+			}
+			const response = await prompts({
+				type: "select",
+				name: "teamId",
+				message: "Select a team:",
+				choices: result.teams.map((team$1) => ({
+					title: team$1.name,
+					value: team$1.id.toString(),
+					description: `ID: ${team$1.id}`
+				}))
+			});
+			if (!response.teamId) {
+				console.log(chalk.yellow("\n❌ Team switch cancelled"));
+				return;
+			}
+			const switchSpinner = ora("Switching team...").start();
+			if (await getProjectConfig()) await updateProjectConfig({
+				activeTeamId: response.teamId,
+				teamId: response.teamId
+			});
+			switchSpinner.succeed(chalk.green("Team switched successfully!"));
+			const selectedTeam = result.teams.find((t) => t.id.toString() === response.teamId);
+			console.log(chalk.cyan(`\n✨ Active team: ${selectedTeam?.name}`));
+			console.log(chalk.white("✅ Your existing API key works for all teams\n"));
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to switch team"));
+			console.error(chalk.red(`\n❌ ${error.message || "An error occurred"}`));
+			process.exit(1);
+		}
+	},
+	async invite(email) {
+		await requireAuth();
+		const spinner = ora(`Inviting ${email}...`).start();
+		try {
+			const activeTeamId = await getActiveTeamId();
+			await getApiClient().inviteToTeam(activeTeamId, email);
+			spinner.succeed(chalk.green(`Invitation sent to ${email}!`));
+			console.log(chalk.gray("\nThey will receive an email with instructions to join the team\n"));
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to send invitation"));
+			console.error(chalk.red(`\n❌ ${error.message || "An error occurred"}`));
+			process.exit(1);
+		}
+	}
+};
+
+//#endregion
+//#region src/lib/fs-utils.ts
+const MCP_JSON_PATH = path.join(process.cwd(), ".mcp.json");
+const CLAUDE_AGENTS_DIR = path.join(process.cwd(), ".claude", "agents");
+const GITIGNORE_PATH = path.join(process.cwd(), ".gitignore");
+async function getMcpConfig() {
+	try {
+		const data = await fs.readFile(MCP_JSON_PATH, "utf-8");
+		return JSON.parse(data);
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+async function saveMcpConfig(config) {
+	await fs.writeFile(MCP_JSON_PATH, JSON.stringify(config, null, 2));
+}
+async function addMcpServer(name, serverConfig) {
+	const config = await getMcpConfig() || { mcpServers: {} };
+	if (!config.mcpServers) config.mcpServers = {};
+	config.mcpServers[name] = serverConfig;
+	await saveMcpConfig(config);
+}
+async function removeMcpServer(name) {
+	const config = await getMcpConfig();
+	if (config?.mcpServers) {
+		delete config.mcpServers[name];
+		await saveMcpConfig(config);
+	}
+}
+async function backupMcpConfig() {
+	try {
+		const data = await fs.readFile(MCP_JSON_PATH, "utf-8");
+		const backupPath = `${MCP_JSON_PATH}.backup`;
+		await fs.writeFile(backupPath, data);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+async function ensureAgentsDir() {
+	try {
+		await fs.access(CLAUDE_AGENTS_DIR);
+	} catch {
+		await fs.mkdir(CLAUDE_AGENTS_DIR, { recursive: true });
+	}
+}
+async function getSubagentFiles() {
+	try {
+		await fs.access(CLAUDE_AGENTS_DIR);
+		const mdFiles = (await fs.readdir(CLAUDE_AGENTS_DIR)).filter((f) => f.endsWith(".md"));
+		const subagents$1 = [];
+		for (const file of mdFiles) {
+			const filePath = path.join(CLAUDE_AGENTS_DIR, file);
+			const parsed = matter(await fs.readFile(filePath, "utf-8"));
+			subagents$1.push({
+				name: parsed.data.name || path.basename(file, ".md"),
+				description: parsed.data.description || "",
+				prompt: parsed.content.trim(),
+				jiveId: parsed.data["jive-id"],
+				filePath
+			});
+		}
+		return subagents$1;
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+}
+async function saveSubagentFile(subagent) {
+	await ensureAgentsDir();
+	const frontmatter = {
+		name: subagent.name,
+		description: subagent.description
+	};
+	if (subagent.jiveId) frontmatter["jive-id"] = subagent.jiveId;
+	const content = matter.stringify(subagent.prompt, frontmatter);
+	const filePath = path.join(CLAUDE_AGENTS_DIR, `${subagent.name}.md`);
+	await fs.writeFile(filePath, content);
+	return filePath;
+}
+async function deleteSubagentFile(name) {
+	const filePath = path.join(CLAUDE_AGENTS_DIR, `${name}.md`);
+	try {
+		await fs.unlink(filePath);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+async function updateSubagentJiveId(name, jiveId) {
+	const filePath = path.join(CLAUDE_AGENTS_DIR, `${name}.md`);
+	const parsed = matter(await fs.readFile(filePath, "utf-8"));
+	parsed.data["jive-id"] = jiveId;
+	const updated = matter.stringify(parsed.content, parsed.data);
+	await fs.writeFile(filePath, updated);
+}
+async function createSubagentRunner() {
+	await ensureAgentsDir();
+	const runnerContent = `---
+name: subagent-runner
+description: Execute dynamically loaded subagent prompts
+---
+
+You are a subagent runner. When invoked, you will receive a subagent prompt
+from the Jive platform. Execute the instructions in that prompt exactly.
+
+The prompt you should execute will be provided via the Task tool's prompt parameter.
+`;
+	const filePath = path.join(CLAUDE_AGENTS_DIR, "subagent-runner.md");
+	await fs.writeFile(filePath, runnerContent);
+}
+async function addToGitignore(pattern) {
+	try {
+		let content = "";
+		try {
+			content = await fs.readFile(GITIGNORE_PATH, "utf-8");
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		if (content.split("\n").some((line) => line.trim() === pattern)) return;
+		const newContent = content.trim() + "\n" + pattern + "\n";
+		await fs.writeFile(GITIGNORE_PATH, newContent);
+	} catch (error) {
+		console.warn(`Warning: Could not update .gitignore: ${error}`);
+	}
+}
+const CLAUDE_PLUGINS_DIR = path.join(process.cwd(), ".claude", "plugins");
+const JIVE_CONFIG_DIR = path.join(process.cwd(), ".jive");
+const JIVE_CONFIG_PATH = path.join(JIVE_CONFIG_DIR, "config.json");
+async function installTelemetryPlugin(apiKey, apiUrl) {
+	await fs.mkdir(CLAUDE_PLUGINS_DIR, { recursive: true });
+	const pluginSourceDir = path.join(process.cwd(), "plugins", "jive-mcp-telemetry");
+	const pluginDestDir = path.join(CLAUDE_PLUGINS_DIR, "jive-mcp-telemetry");
+	let pluginExists = false;
+	try {
+		await fs.access(pluginSourceDir);
+		pluginExists = true;
+	} catch {
+		pluginExists = false;
+	}
+	if (pluginExists) await copyDirectory(pluginSourceDir, pluginDestDir);
+	else await createMinimalPlugin(pluginDestDir);
+	await fs.mkdir(JIVE_CONFIG_DIR, { recursive: true });
+	let config = {};
+	try {
+		const existingConfig = await fs.readFile(JIVE_CONFIG_PATH, "utf-8");
+		config = JSON.parse(existingConfig);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	config.apiUrl = apiUrl;
+	config.apiKey = apiKey;
+	await fs.writeFile(JIVE_CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+async function copyDirectory(src, dest) {
+	await fs.mkdir(dest, { recursive: true });
+	const entries = await fs.readdir(src, { withFileTypes: true });
+	for (const entry of entries) {
+		const srcPath = path.join(src, entry.name);
+		const destPath = path.join(dest, entry.name);
+		if (entry.isDirectory()) await copyDirectory(srcPath, destPath);
+		else await fs.copyFile(srcPath, destPath);
+	}
+}
+async function createMinimalPlugin(pluginDir) {
+	await fs.mkdir(path.join(pluginDir, ".claude-plugin"), { recursive: true });
+	await fs.mkdir(path.join(pluginDir, "hooks"), { recursive: true });
+	await fs.mkdir(path.join(pluginDir, "scripts"), { recursive: true });
+	await fs.writeFile(path.join(pluginDir, ".claude-plugin", "plugin.json"), JSON.stringify({
+		name: "jive-mcp-telemetry",
+		version: "1.0.0",
+		description: "Captures subagent execution traces and tool calls for Jive",
+		author: {
+			name: "Jive",
+			url: "https://github.com/jive-mcp"
+		},
+		license: "MIT",
+		keywords: [
+			"subagents",
+			"telemetry",
+			"monitoring",
+			"debugging"
+		],
+		hooks: "../hooks/hooks.json"
+	}, null, 2));
+	await fs.writeFile(path.join(pluginDir, "hooks", "hooks.json"), JSON.stringify({ hooks: { PostToolUse: [{
+		matcher: ".*",
+		hooks: [{
+			type: "command",
+			command: "node ${CLAUDE_PLUGIN_ROOT}/scripts/capture-tool-use.js"
+		}]
+	}] } }, null, 2));
+	await fs.writeFile(path.join(pluginDir, "scripts", "capture-tool-use.js"), `#!/usr/bin/env node
+
+/**
+ * Jive Telemetry Capture Script
+ *
+ * This script runs as a PostToolUse hook to capture tool calls made during
+ * subagent execution and send them to the Jive API for tracking.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+
+// Find the project's .jive/config.json by searching upward from cwd
+function findProjectConfig() {
+  let dir = process.cwd();
+  while (dir !== path.parse(dir).root) {
+    const configPath = path.join(dir, '.jive', 'config.json');
+    if (fs.existsSync(configPath)) {
+      return configPath;
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+const CONFIG_FILE = findProjectConfig();
+const STATE_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.jive-mcp', 'telemetry');
+const LOG_FILE = path.join(STATE_DIR, 'telemetry.log');
+
+// Ensure state directory exists
+try {
+  if (!fs.existsSync(STATE_DIR)) {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+  }
+} catch (err) {
+  process.exit(0);
+}
+
+function log(message) {
+  try {
+    const timestamp = new Date().toISOString();
+    fs.appendFileSync(LOG_FILE, \`[\${timestamp}] \${message}\\n\`);
+  } catch (err) {
+    // Ignore logging errors
+  }
+}
+
+function loadConfig() {
+  try {
+    if (!CONFIG_FILE || !fs.existsSync(CONFIG_FILE)) {
+      log('Config file not found, telemetry disabled');
+      return null;
+    }
+    const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    return config;
+  } catch (err) {
+    log(\`Error loading config: \${err.message}\`);
+    return null;
+  }
+}
+
+function getCurrentInvocation() {
+  try {
+    const stateFile = path.join(STATE_DIR, 'current-invocation.json');
+    if (!fs.existsSync(stateFile)) {
+      return null;
+    }
+    const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+    const age = Date.now() - state.timestamp;
+    if (age > 3600000) {
+      fs.unlinkSync(stateFile);
+      return null;
+    }
+    return state;
+  } catch (err) {
+    log(\`Error reading invocation state: \${err.message}\`);
+    return null;
+  }
+}
+
+function getNextSequenceNumber(invocationId) {
+  const seqFile = path.join(STATE_DIR, \`seq-\${invocationId}.txt\`);
+  try {
+    let seq = 1;
+    if (fs.existsSync(seqFile)) {
+      seq = parseInt(fs.readFileSync(seqFile, 'utf8')) + 1;
+    }
+    fs.writeFileSync(seqFile, seq.toString());
+    return seq;
+  } catch (err) {
+    log(\`Error managing sequence number: \${err.message}\`);
+    return 1;
+  }
+}
+
+// Simplified version - full implementation in the source repository
+log('Telemetry hook triggered (minimal version)');
+process.exit(0);
+`);
+	await fs.chmod(path.join(pluginDir, "scripts", "capture-tool-use.js"), 493);
+}
+async function getPluginStatus() {
+	const pluginPath = path.join(CLAUDE_PLUGINS_DIR, "jive-mcp-telemetry");
+	const configPath = JIVE_CONFIG_PATH;
+	let installed = false;
+	let configured = false;
+	try {
+		await fs.access(pluginPath);
+		installed = true;
+	} catch {
+		installed = false;
+	}
+	try {
+		await fs.access(configPath);
+		configured = true;
+	} catch {
+		configured = false;
+	}
+	return {
+		installed,
+		configured,
+		pluginPath: installed ? pluginPath : void 0,
+		configPath: configured ? configPath : void 0
+	};
+}
+
+//#endregion
+//#region src/commands/init.ts
+async function initCommand() {
+	console.log(chalk.bold("\n🚀 Initialize Jive\n"));
+	if (await isProjectInitialized()) {
+		if (!(await prompts({
+			type: "confirm",
+			name: "continue",
+			message: "Project is already initialized. Continue anyway?",
+			initial: false
+		})).continue) {
+			console.log(chalk.yellow("\n❌ Initialization cancelled"));
+			return;
+		}
+	}
+	await requireAuth();
+	let teamId;
+	const apiClient$1 = getApiClient();
+	const credentials = await getCredentials();
+	if (!credentials) {
+		console.error(chalk.red("Not authenticated"));
+		process.exit(1);
+	}
+	const teamsResult = await apiClient$1.getTeams();
+	if (teamsResult.teams.length === 0) {
+		console.log(chalk.yellow("\n⚠️  You are not a member of any teams"));
+		console.log(chalk.white("Run"), chalk.cyan("jive team create"), chalk.white("to create a team first\n"));
+		process.exit(1);
+	}
+	if (teamsResult.teams.length === 1) {
+		teamId = teamsResult.teams[0].id.toString();
+		console.log(chalk.white(`Using team: ${chalk.cyan(teamsResult.teams[0].name)}\n`));
+	} else {
+		const response = await prompts({
+			type: "select",
+			name: "teamId",
+			message: "Select a team to initialize for:",
+			choices: teamsResult.teams.map((team$1) => ({
+				title: team$1.name,
+				value: team$1.id.toString(),
+				description: `ID: ${team$1.id}`
+			}))
+		});
+		if (!response.teamId) {
+			console.log(chalk.yellow("\n❌ Initialization cancelled"));
+			return;
+		}
+		teamId = response.teamId;
+	}
+	const spinner = ora("Initializing project...").start();
+	try {
+		spinner.text = "Scanning for existing MCP servers...";
+		const mcpConfig = await getMcpConfig();
+		let uploadedServers = 0;
+		if (mcpConfig?.mcpServers) {
+			const serverNames = Object.keys(mcpConfig.mcpServers).filter((name) => name !== "jive-mcp");
+			if (serverNames.length > 0) {
+				spinner.text = `Found ${serverNames.length} MCP server(s), uploading...`;
+				for (const name of serverNames) {
+					const serverConfig = mcpConfig.mcpServers[name];
+					try {
+						await apiClient$1.createMcpServer(teamId, {
+							name,
+							description: `Imported from local .mcp.json`,
+							config: serverConfig
+						});
+						uploadedServers++;
+					} catch (error) {
+						console.warn(chalk.gray(`\nWarning: Could not upload MCP server "${name}": ${error.message}`));
+					}
+				}
+			}
+		}
+		spinner.text = "Scanning for existing subagents...";
+		const subagentFiles = await getSubagentFiles();
+		let uploadedSubagents = 0;
+		if (subagentFiles.length > 0) {
+			spinner.text = `Found ${subagentFiles.length} subagent(s), uploading...`;
+			for (const subagent of subagentFiles) {
+				if (subagent.name === "subagent-runner") continue;
+				try {
+					const created = await apiClient$1.createSubagent(teamId, {
+						name: subagent.name,
+						description: subagent.description,
+						prompt: subagent.prompt
+					});
+					await updateSubagentJiveId(subagent.name, created.id);
+					uploadedSubagents++;
+				} catch (error) {
+					console.warn(chalk.gray(`\nWarning: Could not upload subagent "${subagent.name}": ${error.message}`));
+				}
+			}
+		}
+		spinner.text = "Adding Jive server to .mcp.json...";
+		await addMcpServer("jive-mcp", {
+			command: "npx",
+			args: ["-y", "@jive/mcp-server"],
+			env: {
+				JIVE_API_URL: process.env.JIVE_API_URL || "http://localhost:5173",
+				JIVE_TEAM_ID: teamId,
+				JIVE_AUTH_TOKEN: credentials.token
+			}
+		});
+		spinner.text = "Creating subagent-runner...";
+		await createSubagentRunner();
+		spinner.text = "Updating .gitignore...";
+		await addToGitignore(".jive/config.json");
+		await addToGitignore(".jive/sync.json");
+		await addToGitignore(".claude/plugins/");
+		spinner.text = "Creating project configuration...";
+		await saveProjectConfig({
+			teamId,
+			activeTeamId: teamId,
+			lastSync: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		spinner.text = "Installing Claude Code telemetry plugin...";
+		const apiUrl = process.env.JIVE_API_URL || "http://localhost:5173";
+		try {
+			await installTelemetryPlugin(credentials.token, apiUrl);
+			spinner.text = "Telemetry plugin installed";
+		} catch (error) {
+			console.warn(chalk.yellow(`\nWarning: Could not install telemetry plugin: ${error.message}`));
+		}
+		spinner.succeed(chalk.green("Project initialized successfully!"));
+		console.log(chalk.bold("\n📦 Summary:\n"));
+		if (uploadedServers > 0) console.log(chalk.green(`  ✓ Uploaded ${uploadedServers} MCP server(s) to team`));
+		if (uploadedSubagents > 0) console.log(chalk.green(`  ✓ Uploaded ${uploadedSubagents} subagent(s) to team`));
+		console.log(chalk.green("  ✓ Added @jive/mcp server to .mcp.json"));
+		console.log(chalk.green("  ✓ Created .claude/agents/subagent-runner.md"));
+		console.log(chalk.green("  ✓ Created .jive/config.json"));
+		console.log(chalk.green("  ✓ Updated .gitignore"));
+		const pluginStatus = await getPluginStatus();
+		if (pluginStatus.installed) console.log(chalk.green("  ✓ Installed telemetry plugin to .claude/plugins/"));
+		console.log(chalk.bold("\n✨ Next Steps:\n"));
+		console.log(chalk.white("  • Restart Claude Code to load the Jive server and telemetry plugin"));
+		console.log(chalk.white("  • Run"), chalk.cyan("jive sync"), chalk.white("to sync resources"));
+		console.log(chalk.white("  • Run"), chalk.cyan("jive status"), chalk.white("to check sync status"));
+		if (pluginStatus.installed) {
+			console.log(chalk.bold("\n🔍 Subagent Visibility:\n"));
+			console.log(chalk.white("  • The telemetry plugin will track subagent executions"));
+			console.log(chalk.white("  • View execution traces in the web UI (View Executions button)"));
+			console.log(chalk.white("  • Generate an API key in the web UI for full telemetry support"));
+			console.log(chalk.gray("    (Settings > API Keys > Create New Key)\n"));
+		} else {
+			console.log(chalk.yellow("\n⚠️  Telemetry plugin installation failed"));
+			console.log(chalk.white("  • Subagent execution tracking will not work"));
+			console.log(chalk.white("  • See SUBAGENT_VISIBILITY.md for manual installation\n"));
+		}
+	} catch (error) {
+		spinner.fail(chalk.red("Initialization failed"));
+		console.error(chalk.red(`\n❌ ${error.message || "An error occurred"}`));
+		if (error.stack) console.error(chalk.gray(error.stack));
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/commands/detach.ts
+async function detachCommand() {
+	console.log(chalk.bold("\n🔌 Detach from Jive\n"));
+	console.log(chalk.white("This will pull all your content from the platform and remove Jive integrations.\n"));
+	if (!(await prompts({
+		type: "confirm",
+		name: "confirm",
+		message: "Are you sure you want to detach from Jive?",
+		initial: false
+	})).confirm) {
+		console.log(chalk.yellow("\n❌ Detach cancelled"));
+		return;
+	}
+	const spinner = ora("Detaching from Jive...").start();
+	try {
+		let pulledSubagents = 0;
+		let pulledMcpServers = 0;
+		const projectConfig = await getProjectConfig();
+		await requireAuth();
+		const apiClient$1 = getApiClient();
+		if (projectConfig) {
+			const teamId = projectConfig.activeTeamId || projectConfig.teamId;
+			spinner.text = "Pulling subagents from platform...";
+			try {
+				const subagents$1 = await apiClient$1.getSubagents(teamId);
+				for (const subagent of subagents$1) {
+					await saveSubagentFile({
+						name: subagent.name,
+						description: subagent.description,
+						prompt: subagent.prompt
+					});
+					pulledSubagents++;
+				}
+			} catch (error) {
+				console.warn(chalk.yellow(`\n⚠️  Could not pull subagents: ${error.message}`));
+			}
+			spinner.text = "Pulling MCP servers from platform...";
+			try {
+				const servers = await apiClient$1.getMcpServers(teamId);
+				for (const server of servers) {
+					if (server.name === "jive-mcp") continue;
+					await addMcpServer(server.name, server.config);
+					pulledMcpServers++;
+				}
+			} catch (error) {
+				console.warn(chalk.yellow(`\n⚠️  Could not pull MCP servers: ${error.message}`));
+			}
+		}
+		spinner.text = "Removing Jive server from .mcp.json...";
+		if ((await getMcpConfig())?.mcpServers?.["jive-mcp"]) await removeMcpServer("jive-mcp");
+		spinner.text = "Removing telemetry plugin...";
+		const pluginPath = path.join(process.cwd(), ".claude", "plugins", "jive-mcp-telemetry");
+		try {
+			await fs.access(pluginPath);
+			await fs.rm(pluginPath, {
+				recursive: true,
+				force: true
+			});
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		spinner.text = "Removing subagent-runner...";
+		const runnerPath = path.join(process.cwd(), ".claude", "agents", "subagent-runner.md");
+		try {
+			await fs.unlink(runnerPath);
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		spinner.text = "Removing .jive directory...";
+		const jivePath = path.join(process.cwd(), ".jive");
+		try {
+			await fs.rm(jivePath, {
+				recursive: true,
+				force: true
+			});
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+		}
+		spinner.text = "Cleaning up .gitignore...";
+		const gitignorePath = path.join(process.cwd(), ".gitignore");
+		try {
+			let content = await fs.readFile(gitignorePath, "utf-8");
+			const linesToRemove = [
+				".jive/config.json",
+				".jive/sync.json",
+				".claude/plugins/"
+			];
+			const lines = content.split("\n");
+			const filteredLines = lines.filter((line) => !linesToRemove.includes(line.trim()));
+			if (filteredLines.length !== lines.length) await fs.writeFile(gitignorePath, filteredLines.join("\n"));
+		} catch (error) {
+			if (error.code !== "ENOENT") console.warn(chalk.gray("\nWarning: Could not update .gitignore"));
+		}
+		spinner.succeed(chalk.green("Successfully detached from Jive!"));
+		console.log(chalk.bold("\n📦 Summary:\n"));
+		if (pulledSubagents > 0) console.log(chalk.green(`  ✓ Pulled ${pulledSubagents} subagent(s) from platform`));
+		if (pulledMcpServers > 0) console.log(chalk.green(`  ✓ Pulled ${pulledMcpServers} MCP server(s) from platform`));
+		console.log(chalk.green("  ✓ Removed Jive server from .mcp.json"));
+		console.log(chalk.green("  ✓ Removed telemetry plugin"));
+		console.log(chalk.green("  ✓ Removed subagent-runner"));
+		console.log(chalk.green("  ✓ Removed .jive directory"));
+		console.log(chalk.green("  ✓ Cleaned up .gitignore"));
+		console.log(chalk.bold("\n✨ Next Steps:\n"));
+		console.log(chalk.white("  • Restart Claude Code to unload Jive integrations"));
+		console.log(chalk.white("  • All your subagents and MCP servers are now local-only"));
+		console.log(chalk.white("  • Run"), chalk.cyan("jive init"), chalk.white("anytime to reconnect\n"));
+	} catch (error) {
+		spinner.fail(chalk.red("Detach failed"));
+		console.error(chalk.red(`\n❌ ${error.message || "An error occurred"}`));
+		if (error.stack) console.error(chalk.gray(error.stack));
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/commands/subagents.ts
+const subagentCommands = {
+	async list() {
+		await requireAuth();
+		const teamId = await getActiveTeamId();
+		const spinner = ora("Fetching subagents...").start();
+		try {
+			const subagents$1 = await getApiClient().getSubagents(teamId);
+			spinner.stop();
+			if (subagents$1.length === 0) {
+				console.log(chalk.yellow("\n⚠️  No subagents found for this team"));
+				console.log(chalk.white("Run"), chalk.cyan("jive subagents create"), chalk.white("to create one\n"));
+				return;
+			}
+			console.log(chalk.bold(`\n📋 Team Subagents (${subagents$1.length}):\n`));
+			for (const subagent of subagents$1) {
+				console.log(chalk.cyan(`  ${subagent.name}`));
+				console.log(chalk.gray(`  ID: ${subagent.id}`));
+				if (subagent.description) console.log(chalk.white(`  ${subagent.description}`));
+				console.log();
+			}
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to fetch subagents"));
+			console.error(chalk.red(`\n❌ ${error.message}`));
+			process.exit(1);
+		}
+	},
+	async pull(options) {
+		await requireAuth();
+		const teamId = await getActiveTeamId();
+		const spinner = ora("Pulling subagents...").start();
+		try {
+			const remoteSubagents = await getApiClient().getSubagents(teamId);
+			if (remoteSubagents.length === 0) {
+				spinner.info(chalk.yellow("No subagents to pull"));
+				return;
+			}
+			const localSubagents = await getSubagentFiles();
+			const localNames = new Set(localSubagents.map((s) => s.name));
+			let pulled = 0;
+			let skipped = 0;
+			for (const subagent of remoteSubagents) {
+				if (localNames.has(subagent.name) && !options.overwrite) {
+					skipped++;
+					continue;
+				}
+				await saveSubagentFile({
+					name: subagent.name,
+					description: subagent.description,
+					prompt: subagent.prompt,
+					jiveId: subagent.id
+				});
+				pulled++;
+			}
+			spinner.succeed(chalk.green("Subagents pulled successfully!"));
+			console.log(chalk.bold("\n📦 Summary:\n"));
+			console.log(chalk.green(`  ✓ Pulled ${pulled} subagent(s)`));
+			if (skipped > 0) console.log(chalk.yellow(`  ⚠ Skipped ${skipped} existing file(s) (use --overwrite to replace)`));
+			console.log();
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to pull subagents"));
+			console.error(chalk.red(`\n❌ ${error.message}`));
+			process.exit(1);
+		}
+	},
+	async push(options) {
+		await requireAuth();
+		const teamId = await getActiveTeamId();
+		const spinner = ora("Pushing subagents...").start();
+		try {
+			const apiClient$1 = getApiClient();
+			const localSubagents = await getSubagentFiles();
+			if (localSubagents.length === 0) {
+				spinner.info(chalk.yellow("No local subagents to push"));
+				return;
+			}
+			let created = 0;
+			let updated = 0;
+			const toUpdate = localSubagents.filter((s) => s.jiveId && s.name !== "subagent-runner");
+			let changeMessage = options.message;
+			if (toUpdate.length > 0 && !changeMessage) {
+				spinner.stop();
+				changeMessage = (await prompts({
+					type: "text",
+					name: "changeMessage",
+					message: "Change description (optional, press Enter to skip):"
+				})).changeMessage;
+				spinner.start("Pushing subagents...");
+			}
+			for (const subagent of localSubagents) {
+				if (subagent.name === "subagent-runner") continue;
+				if (subagent.jiveId) {
+					await apiClient$1.updateSubagent(subagent.jiveId, {
+						name: subagent.name,
+						description: subagent.description,
+						prompt: subagent.prompt,
+						changeMessage: changeMessage || void 0
+					});
+					updated++;
+				} else {
+					const result = await apiClient$1.createSubagent(teamId, {
+						name: subagent.name,
+						description: subagent.description,
+						prompt: subagent.prompt
+					});
+					await updateSubagentJiveId(subagent.name, result.id);
+					created++;
+				}
+			}
+			spinner.succeed(chalk.green("Subagents pushed successfully!"));
+			console.log(chalk.bold("\n📦 Summary:\n"));
+			if (created > 0) console.log(chalk.green(`  ✓ Created ${created} subagent(s)`));
+			if (updated > 0) {
+				console.log(chalk.green(`  ✓ Updated ${updated} subagent(s)`));
+				if (changeMessage) console.log(chalk.gray(`    Change: "${changeMessage}"`));
+			}
+			console.log();
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to push subagents"));
+			console.error(chalk.red(`\n❌ ${error.message}`));
+			process.exit(1);
+		}
+	},
+	async create() {
+		await requireAuth();
+		const teamId = await getActiveTeamId();
+		console.log(chalk.bold("\n✨ Create a New Subagent\n"));
+		const response = await prompts([
+			{
+				type: "text",
+				name: "name",
+				message: "Subagent name:",
+				validate: (value) => value ? true : "Name is required"
+			},
+			{
+				type: "text",
+				name: "description",
+				message: "Description:"
+			},
+			{
+				type: "text",
+				name: "prompt",
+				message: "Prompt:",
+				validate: (value) => value ? true : "Prompt is required"
+			}
+		]);
+		if (!response.name || !response.prompt) {
+			console.log(chalk.yellow("\n❌ Creation cancelled"));
+			return;
+		}
+		const spinner = ora("Creating subagent...").start();
+		try {
+			const result = await getApiClient().createSubagent(teamId, {
+				name: response.name,
+				description: response.description || "",
+				prompt: response.prompt
+			});
+			await saveSubagentFile({
+				name: result.name,
+				description: result.description,
+				prompt: result.prompt,
+				jiveId: result.id
+			});
+			spinner.succeed(chalk.green("Subagent created successfully!"));
+			console.log(chalk.cyan(`\n✨ ${result.name}`));
+			console.log(chalk.gray(`   ID: ${result.id}`));
+			console.log(chalk.white(`\n✅ Saved to .claude/agents/${result.name}.md\n`));
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to create subagent"));
+			console.error(chalk.red(`\n❌ ${error.message}`));
+			process.exit(1);
+		}
+	},
+	async delete(nameOrId) {
+		await requireAuth();
+		const teamId = await getActiveTeamId();
+		const spinner = ora("Finding subagent...").start();
+		try {
+			const apiClient$1 = getApiClient();
+			const subagent = (await apiClient$1.getSubagents(teamId)).find((s) => s.name === nameOrId || s.id === nameOrId);
+			if (!subagent) {
+				spinner.fail(chalk.red("Subagent not found"));
+				console.log(chalk.yellow(`\n⚠️  No subagent found with name or ID: ${nameOrId}\n`));
+				return;
+			}
+			spinner.stop();
+			if (!(await prompts({
+				type: "confirm",
+				name: "confirm",
+				message: `Delete subagent "${subagent.name}"?`,
+				initial: false
+			})).confirm) {
+				console.log(chalk.yellow("\n❌ Deletion cancelled"));
+				return;
+			}
+			const deleteSpinner = ora("Deleting subagent...").start();
+			await apiClient$1.deleteSubagent(subagent.id);
+			await deleteSubagentFile(subagent.name);
+			deleteSpinner.succeed(chalk.green("Subagent deleted successfully!"));
+			console.log();
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to delete subagent"));
+			console.error(chalk.red(`\n❌ ${error.message}`));
+			process.exit(1);
+		}
+	}
+};
+
+//#endregion
+//#region src/mcp/codegen.ts
+/**
+* Convert JSON Schema to TypeScript interface string
+*/
+function jsonSchemaToTypescript(schema, interfaceName, indent = "") {
+	if (!schema || typeof schema !== "object") return "any";
+	if (schema.type && !schema.properties) switch (schema.type) {
+		case "string": return schema.enum ? schema.enum.map((e) => `"${e}"`).join(" | ") : "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		case "null": return "null";
+		case "array":
+			if (schema.items) return `${jsonSchemaToTypescript(schema.items, "", indent)}[]`;
+			return "any[]";
+		case "object":
+			if (!schema.properties) return "Record<string, any>";
+			break;
+		default: return "any";
+	}
+	if (schema.properties) return `{\n${Object.entries(schema.properties).map(([key, propSchema]) => {
+		const optional = schema.required?.includes(key) ?? false ? "" : "?";
+		const propType = jsonSchemaToTypescript(propSchema, "", indent + "  ");
+		return `${propSchema.description ? `${indent}  /**\n${indent}   * ${propSchema.description}\n${indent}   */\n${indent}  ` : `${indent}  `}${key}${optional}: ${propType};`;
+	}).join("\n")}\n${indent}}`;
+	return "any";
+}
+/**
+* Generate interface definition for input schema
+*/
+function generateInputInterface(toolName, inputSchema) {
+	if (!inputSchema || !inputSchema.properties || Object.keys(inputSchema.properties).length === 0) return "";
+	const interfaceName = toPascalCase(toolName) + "Input";
+	return `interface ${interfaceName} ${jsonSchemaToTypescript(inputSchema, interfaceName, "")}\n`;
+}
+/**
+* Generate interface definition for output schema
+*/
+function generateOutputInterface(toolName, outputSchema) {
+	if (!outputSchema || !outputSchema.properties || Object.keys(outputSchema.properties).length === 0) return `interface ${toPascalCase(toolName)}Response {\n  [key: string]: any;\n}\n`;
+	const interfaceName = toPascalCase(toolName) + "Response";
+	return `interface ${interfaceName} ${jsonSchemaToTypescript(outputSchema, interfaceName, "")}\n`;
+}
+/**
+* Convert kebab-case or snake_case to PascalCase
+*/
+function toPascalCase(str) {
+	return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+/**
+* Convert kebab-case or snake_case to camelCase
+*/
+function toCamelCase(str) {
+	const pascal = toPascalCase(str);
+	return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+/**
+* Generate complete TypeScript tool definition
+*
+* Example output:
+* ```ts
+* import { callMcpTool } from "./runtime";
+*
+* interface GetDocumentInput {
+*   documentId: string;
+* }
+*
+* interface GetDocumentResponse {
+*   content: string;
+* }
+*
+* // Read a document from Google Drive
+* export async function getDocument(input: GetDocumentInput): Promise<GetDocumentResponse> {
+*   return callMcpTool<GetDocumentResponse>('google-drive', 'get_document', input);
+* }
+* ```
+*/
+function generateToolDefinition(serverName, tool) {
+	const functionName = toCamelCase(tool.name);
+	const hasInput = tool.inputSchema?.properties && Object.keys(tool.inputSchema.properties).length > 0;
+	const inputTypeName = hasInput ? `${toPascalCase(tool.name)}Input` : "void";
+	const outputTypeName = `${toPascalCase(tool.name)}Response`;
+	const inputInterface = generateInputInterface(tool.name, tool.inputSchema);
+	const outputInterface = generateOutputInterface(tool.name, tool.outputSchema);
+	const inputParam = hasInput ? `input: ${inputTypeName}` : "";
+	const callArgs = hasInput ? `input` : "{}";
+	return `import { callMcpTool } from "./runtime";
+
+${inputInterface}${outputInterface}
+/**
+ * ${tool.description || `Execute ${tool.name} tool`}
+ */
+export async function ${functionName}(${inputParam}): Promise<${outputTypeName}> {
+  return callMcpTool<${outputTypeName}>('${serverName}', '${tool.name}', ${callArgs});
+}
+`;
+}
+/**
+* Generate a unique tool ID for referencing
+*/
+function generateToolId(serverName, toolName) {
+	return `${serverName}__${toolName}`;
+}
+
+//#endregion
+//#region src/mcp/connection-manager.ts
+/**
+* MCP Connection Manager
+* Manages connections to multiple MCP servers, introspects tools, and provides search/execute functionality
+*/
+var McpConnectionManager = class {
+	clients = /* @__PURE__ */ new Map();
+	tools = /* @__PURE__ */ new Map();
+	serverConfigs = /* @__PURE__ */ new Map();
+	/**
+	* Initialize connections to all MCP servers
+	*/
+	async initialize(configs) {
+		console.error(`Initializing ${configs.length} MCP server(s)...`);
+		for (const config of configs) try {
+			await this.connectToServer(config);
+		} catch (error) {
+			console.error(`Failed to connect to ${config.name}:`, error);
+		}
+		console.error(`Connected to ${this.clients.size} MCP server(s)`);
+		await this.introspectTools();
+	}
+	/**
+	* Connect to a single MCP server
+	*/
+	async connectToServer(config) {
+		console.error(`Connecting to ${config.name}...`);
+		const cleanEnv = {};
+		for (const [key, value] of Object.entries(process.env)) if (value !== void 0) cleanEnv[key] = value;
+		const transport = new StdioClientTransport({
+			command: config.config.command,
+			args: config.config.args || [],
+			env: {
+				...cleanEnv,
+				...config.config.env || {}
+			}
+		});
+		const client = new Client({
+			name: "jive-mcp-client",
+			version: "1.0.0"
+		}, { capabilities: {} });
+		await client.connect(transport);
+		this.clients.set(config.name, client);
+		this.serverConfigs.set(config.name, config);
+		console.error(`✓ Connected to ${config.name}`);
+	}
+	/**
+	* Introspect tools from all connected servers and generate TypeScript definitions
+	*/
+	async introspectTools() {
+		console.error("Introspecting tools from connected servers...");
+		for (const [serverName, client] of this.clients.entries()) try {
+			const result = await client.listTools();
+			console.error(`Found ${result.tools.length} tool(s) in ${serverName}`);
+			for (const tool of result.tools) {
+				const toolId = generateToolId(serverName, tool.name);
+				const tsDefinition = generateToolDefinition(serverName, {
+					name: tool.name,
+					description: tool.description,
+					inputSchema: tool.inputSchema
+				});
+				this.tools.set(toolId, {
+					id: toolId,
+					serverName,
+					toolName: tool.name,
+					description: tool.description || "",
+					inputSchema: tool.inputSchema,
+					outputSchema: void 0,
+					tsDefinition
+				});
+			}
+		} catch (error) {
+			console.error(`Failed to introspect tools from ${serverName}:`, error);
+		}
+		console.error(`✓ Generated TypeScript for ${this.tools.size} tool(s)`);
+	}
+	/**
+	* Search tools by query string (matches name or description)
+	*/
+	searchTools(query) {
+		const lowerQuery = query.toLowerCase();
+		const results = [];
+		for (const tool of this.tools.values()) {
+			const nameMatch = tool.toolName.toLowerCase().includes(lowerQuery);
+			const descMatch = tool.description.toLowerCase().includes(lowerQuery);
+			if (nameMatch || descMatch) results.push({
+				id: tool.id,
+				name: tool.toolName,
+				description: tool.description
+			});
+		}
+		return results;
+	}
+	/**
+	* Get full tool definitions including TypeScript code
+	*/
+	getTools(toolIds) {
+		const results = [];
+		for (const toolId of toolIds) {
+			const tool = this.tools.get(toolId);
+			if (tool) results.push({
+				id: tool.id,
+				name: tool.toolName,
+				description: tool.description,
+				tsDefinition: tool.tsDefinition
+			});
+		}
+		return results;
+	}
+	/**
+	* Call an MCP tool
+	*/
+	async callTool(serverName, toolName, args) {
+		const client = this.clients.get(serverName);
+		if (!client) throw new Error(`MCP server '${serverName}' not connected`);
+		return await client.callTool({
+			name: toolName,
+			arguments: args
+		});
+	}
+	/**
+	* Get all connected server names
+	*/
+	getConnectedServers() {
+		return Array.from(this.clients.keys());
+	}
+	/**
+	* Get total tool count
+	*/
+	getToolCount() {
+		return this.tools.size;
+	}
+	/**
+	* Shutdown all connections
+	*/
+	async shutdown() {
+		console.error("Shutting down MCP connections...");
+		for (const [serverName, client] of this.clients.entries()) try {
+			await client.close();
+			console.error(`✓ Disconnected from ${serverName}`);
+		} catch (error) {
+			console.error(`Error disconnecting from ${serverName}:`, error);
+		}
+		this.clients.clear();
+		this.tools.clear();
+		this.serverConfigs.clear();
+	}
+};
+
+//#endregion
+//#region src/mcp/index.ts
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const LOG_FILE = process.env.JIVE_LOG_FILE || path.join(__dirname, "../jive-mcp.log");
+const logStream = fs$1.createWriteStream(LOG_FILE, { flags: "a" });
+function log(...args) {
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	const message = args.map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)).join(" ");
+	logStream.write(`[${timestamp}] ${message}\n`);
+}
+/**
+* Stdio MCP server that calls HTTP API endpoints
+* Requires JIVE_API_KEY environment variable
+* Optionally accepts JIVE_API_URL (defaults to http://localhost:5173)
+*/
+async function startMcpServer() {
+	log("=== Jive Server Starting ===");
+	const apiKey = process.env.JIVE_API_KEY;
+	const apiUrl = process.env.JIVE_API_URL || "http://localhost:5173";
+	if (!apiKey) {
+		log("Error: JIVE_API_KEY environment variable is required");
+		log("Usage: JIVE_API_KEY=jive_xxx npm run mcp");
+		process.exit(1);
+	}
+	if (!apiKey.startsWith("jive_")) {
+		log("Error: JIVE_API_KEY must start with \"jive_\"");
+		process.exit(1);
+	}
+	log(`Jive server connecting to ${apiUrl}`);
+	const connectionManager = new McpConnectionManager();
+	try {
+		const response = await fetch(`${apiUrl}/api/mcp-config`, {
+			method: "GET",
+			headers: { "X-API-Key": apiKey }
+		});
+		if (!response.ok) throw new Error(`Failed to fetch MCP configs: ${response.status} ${response.statusText}`);
+		const { servers } = await response.json();
+		log(`Found ${servers.length} MCP server config(s)`);
+		if (servers.length > 0) await connectionManager.initialize(servers);
+		else log("No MCP servers configured for this team");
+	} catch (error) {
+		log("Error fetching MCP configs:", error);
+		log("Continuing without MCP tool connections...");
+	}
+	const server = new Server({
+		name: "jive-mcp",
+		version: "1.0.0"
+	}, { capabilities: { tools: {} } });
+	server.setRequestHandler(ListToolsRequestSchema, async () => {
+		return { tools: [
+			{
+				name: "search_subagents",
+				description: "Search for subagents by name or description",
+				inputSchema: {
+					type: "object",
+					properties: { query: {
+						type: "string",
+						description: "Search query for subagents"
+					} },
+					required: ["query"]
+				}
+			},
+			{
+				name: "call_subagent",
+				description: "Get a subagent's prompt formatted with user input",
+				inputSchema: {
+					type: "object",
+					properties: {
+						id: {
+							type: "number",
+							description: "Subagent ID"
+						},
+						prompt: {
+							type: "string",
+							description: "Prompt to pass to the subagent"
+						}
+					},
+					required: ["id", "prompt"]
+				}
+			},
+			{
+				name: "search_tools",
+				description: "Search for MCP tools by name or description. Returns lightweight list of tool names and descriptions.",
+				inputSchema: {
+					type: "object",
+					properties: { query: {
+						type: "string",
+						description: "Search query for tools"
+					} },
+					required: ["query"]
+				}
+			},
+			{
+				name: "get_tools",
+				description: "Get full TypeScript definitions for specific tools by their IDs",
+				inputSchema: {
+					type: "object",
+					properties: { ids: {
+						type: "array",
+						items: { type: "string" },
+						description: "Array of tool IDs to retrieve"
+					} },
+					required: ["ids"]
+				}
+			},
+			{
+				name: "call_tool",
+				description: "Execute TypeScript code that calls MCP tools. Returns the result of execution.",
+				inputSchema: {
+					type: "object",
+					properties: { code: {
+						type: "string",
+						description: "TypeScript code to execute"
+					} },
+					required: ["code"]
+				}
+			}
+		] };
+	});
+	async function apiRequest(endpoint, body) {
+		const url = `${apiUrl}${endpoint}`;
+		try {
+			const response = await fetch(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					"X-API-Key": apiKey
+				},
+				body: body ? JSON.stringify(body) : void 0
+			});
+			if (!response.ok) {
+				const errorText = await response.text();
+				let errorMessage;
+				try {
+					errorMessage = JSON.parse(errorText).error || errorText;
+				} catch {
+					errorMessage = errorText;
+				}
+				throw new Error(`API request failed (${response.status}): ${errorMessage}`);
+			}
+			return await response.json();
+		} catch (error) {
+			if (error instanceof Error) throw error;
+			throw new Error(`API request failed: ${String(error)}`);
+		}
+	}
+	server.setRequestHandler(CallToolRequestSchema, async (request) => {
+		const { name, arguments: args } = request.params;
+		log(`Tool called: ${name}`, { args });
+		try {
+			if (!args) throw new Error("Missing arguments");
+			switch (name) {
+				case "search_subagents": {
+					const results = await apiRequest("/api/subagents/search", { query: args.query });
+					return { content: [{
+						type: "text",
+						text: JSON.stringify(results, null, 2)
+					}] };
+				}
+				case "call_subagent": return { content: [{
+					type: "text",
+					text: (await apiRequest(`/api/subagents/${args.id}/call`, { prompt: args.prompt })).prompt
+				}] };
+				case "search_tools": {
+					const results = connectionManager.searchTools(args.query);
+					return { content: [{
+						type: "text",
+						text: JSON.stringify(results, null, 2)
+					}] };
+				}
+				case "get_tools": return { content: [{
+					type: "text",
+					text: connectionManager.getTools(args.ids).map((tool) => {
+						return `// Tool ID: ${tool.id}\n// ${tool.description}\n\n${tool.tsDefinition}`;
+					}).join("\n\n---\n\n") || "No tools found"
+				}] };
+				case "call_tool": try {
+					let code = args.code;
+					code = code.replace(/import\s+.*?from\s+['"].*?['"];?\s*/g, "");
+					const result = ts.transpileModule(code, { compilerOptions: {
+						module: ts.ModuleKind.ESNext,
+						target: ts.ScriptTarget.ES2020
+					} });
+					if (result.diagnostics && result.diagnostics.length > 0) return {
+						content: [{
+							type: "text",
+							text: `TypeScript validation failed:\n${result.diagnostics.map((d) => ts.flattenDiagnosticMessageText(d.messageText, "\n")).join("\n")}`
+						}],
+						isError: true
+					};
+					const consoleOutput = [];
+					let executionResult = null;
+					const callMcpTool = async (serverName, toolName, args$1) => {
+						log("Calling MCP tool:", {
+							serverName,
+							toolName,
+							args: args$1
+						});
+						try {
+							const result$1 = await connectionManager.callTool(serverName, toolName, args$1);
+							log("MCP tool call result:", result$1);
+							return result$1;
+						} catch (error) {
+							throw new Error(`MCP tool call failed: ${error instanceof Error ? error.message : String(error)}`);
+						}
+					};
+					const done = (result$1) => {
+						executionResult = result$1;
+					};
+					const customConsole = { log: (...args$1) => {
+						consoleOutput.push(args$1.map(String).join(" "));
+						log("User code log:", args$1.map(String).join(" "));
+					} };
+					const wrappedCode = `(async () => { ${result.outputText} })()`;
+					const executeCode = new Function("callMcpTool", "done", "console", `return ${wrappedCode}`);
+					log("Executing tool code");
+					log("Wrapped code:", executeCode);
+					const returnValue = await executeCode(callMcpTool, done, customConsole);
+					log("Tool code execution result:", returnValue);
+					const finalResult = executionResult !== null && executionResult !== void 0 ? executionResult : returnValue;
+					if (finalResult !== null && finalResult !== void 0) return { content: [{
+						type: "text",
+						text: typeof finalResult === "string" ? finalResult : JSON.stringify(finalResult, null, 2)
+					}] };
+					return { content: [{
+						type: "text",
+						text: consoleOutput.length > 0 ? consoleOutput.join("\n") : "Code executed successfully (no output)"
+					}] };
+				} catch (error) {
+					return {
+						content: [{
+							type: "text",
+							text: `Execution error: ${error instanceof Error ? error.message : String(error)}`
+						}],
+						isError: true
+					};
+				}
+				default: throw new Error(`Unknown tool: ${name}`);
+			}
+		} catch (error) {
+			return {
+				content: [{
+					type: "text",
+					text: `Error: ${error instanceof Error ? error.message : String(error)}`
+				}],
+				isError: true
+			};
+		}
+	});
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	log("Jive server running on stdio");
+	log(`Logging to: ${LOG_FILE}`);
+	process.on("SIGINT", async () => {
+		log("Shutting down via SIGINT...");
+		await connectionManager.shutdown();
+		logStream.end();
+		process.exit(0);
+	});
+	process.on("SIGTERM", async () => {
+		log("Shutting down via SIGTERM...");
+		await connectionManager.shutdown();
+		logStream.end();
+		process.exit(0);
+	});
+}
+var mcp_default = startMcpServer;
+
+//#endregion
+//#region src/commands/mcp.ts
+const mcpCommands = {
+	async list() {
+		await requireAuth();
+		const teamId = await getActiveTeamId();
+		const spinner = ora("Fetching MCP servers...").start();
+		try {
+			const servers = await getApiClient().getMcpServers(teamId);
+			spinner.stop();
+			if (servers.length === 0) {
+				console.log(chalk.yellow("\n⚠️  No MCP servers found for this team"));
+				console.log(chalk.white("Run"), chalk.cyan("jive mcp add"), chalk.white("to add one\n"));
+				return;
+			}
+			console.log(chalk.bold(`\n🔧 Team MCP Servers (${servers.length}):\n`));
+			for (const server of servers) {
+				console.log(chalk.cyan(`  ${server.name}`));
+				console.log(chalk.gray(`  ID: ${server.id}`));
+				if (server.config?.command) console.log(chalk.white(`  Command: ${server.config.command} ${server.config.args?.join(" ") || ""}`));
+				console.log();
+			}
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to fetch MCP servers"));
+			console.error(chalk.red(`\n❌ ${error.message}`));
+			process.exit(1);
+		}
+	},
+	async pull(options) {
+		await requireAuth();
+		const teamId = await getActiveTeamId();
+		const spinner = ora("Pulling MCP servers...").start();
+		try {
+			const remoteServers = await getApiClient().getMcpServers(teamId);
+			if (remoteServers.length === 0) {
+				spinner.info(chalk.yellow("No MCP servers to pull"));
+				return;
+			}
+			await backupMcpConfig();
+			const localConfig = await getMcpConfig();
+			const newServers = {};
+			for (const server of remoteServers) newServers[server.name] = server.config;
+			if (options.merge && localConfig?.mcpServers) await saveMcpConfig({ mcpServers: {
+				...localConfig.mcpServers,
+				...newServers
+			} });
+			else {
+				const jiveServer = localConfig?.mcpServers?.["jive-mcp"];
+				const servers = { ...newServers };
+				if (jiveServer) servers["jive-mcp"] = jiveServer;
+				await saveMcpConfig({ mcpServers: servers });
+			}
+			spinner.succeed(chalk.green("MCP servers pulled successfully!"));
+			console.log(chalk.bold("\n📦 Summary:\n"));
+			console.log(chalk.green(`  ✓ Pulled ${remoteServers.length} MCP server(s)`));
+			if (options.merge) console.log(chalk.cyan("  ℹ Merged with local servers"));
+			else console.log(chalk.cyan("  ℹ Replaced local servers"));
+			console.log(chalk.gray(`  ✓ Backup saved to .mcp.json.backup`));
+			console.log();
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to pull MCP servers"));
+			console.error(chalk.red(`\n❌ ${error.message}`));
+			process.exit(1);
+		}
+	},
+	async push(options) {
+		await requireAuth();
+		const teamId = await getActiveTeamId();
+		const spinner = ora("Pushing MCP servers...").start();
+		try {
+			const apiClient$1 = getApiClient();
+			const localConfig = await getMcpConfig();
+			if (!localConfig?.mcpServers) {
+				spinner.info(chalk.yellow("No local MCP servers to push"));
+				return;
+			}
+			let created = 0;
+			let errors = 0;
+			const serverNames = Object.keys(localConfig.mcpServers).filter((name) => name !== "jive-mcp");
+			for (const name of serverNames) {
+				const config = localConfig.mcpServers[name];
+				try {
+					await apiClient$1.createMcpServer(teamId, {
+						name,
+						description: `Pushed from local .mcp.json`,
+						config
+					});
+					created++;
+				} catch (error) {
+					console.warn(chalk.gray(`\nWarning: Could not push "${name}": ${error.message}`));
+					errors++;
+				}
+			}
+			spinner.succeed(chalk.green("MCP servers pushed!"));
+			console.log(chalk.bold("\n📦 Summary:\n"));
+			console.log(chalk.green(`  ✓ Pushed ${created} MCP server(s)`));
+			if (errors > 0) console.log(chalk.yellow(`  ⚠ ${errors} error(s) (servers may already exist)`));
+			console.log();
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to push MCP servers"));
+			console.error(chalk.red(`\n❌ ${error.message}`));
+			process.exit(1);
+		}
+	},
+	async add(name) {
+		await requireAuth();
+		const teamId = await getActiveTeamId();
+		console.log(chalk.bold(`\n➕ Add MCP Server: ${name}\n`));
+		const response = await prompts([
+			{
+				type: "text",
+				name: "command",
+				message: "Command (e.g., npx, node, python):",
+				validate: (value) => value ? true : "Command is required"
+			},
+			{
+				type: "list",
+				name: "args",
+				message: "Arguments (comma-separated):",
+				separator: ","
+			},
+			{
+				type: "text",
+				name: "env",
+				message: "Environment variables (key=value, comma-separated):"
+			}
+		]);
+		if (!response.command) {
+			console.log(chalk.yellow("\n❌ Cancelled"));
+			return;
+		}
+		const config = { command: response.command };
+		if (response.args && response.args.length > 0) config.args = response.args;
+		if (response.env) {
+			config.env = {};
+			const envPairs = response.env.split(",");
+			for (const pair of envPairs) {
+				const [key, value] = pair.split("=");
+				if (key && value) config.env[key.trim()] = value.trim();
+			}
+		}
+		const spinner = ora("Adding MCP server...").start();
+		try {
+			await getApiClient().createMcpServer(teamId, {
+				name,
+				description: "",
+				config
+			});
+			await addMcpServer(name, config);
+			spinner.succeed(chalk.green("MCP server added successfully!"));
+			console.log(chalk.cyan(`\n✨ ${name}`));
+			console.log(chalk.white(`   Command: ${config.command} ${config.args?.join(" ") || ""}`));
+			console.log(chalk.white("\n✅ Added to team and local .mcp.json\n"));
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to add MCP server"));
+			console.error(chalk.red(`\n❌ ${error.message}`));
+			process.exit(1);
+		}
+	},
+	async remove(nameOrId) {
+		await requireAuth();
+		const teamId = await getActiveTeamId();
+		const spinner = ora("Finding MCP server...").start();
+		try {
+			const apiClient$1 = getApiClient();
+			const server = (await apiClient$1.getMcpServers(teamId)).find((s) => s.name === nameOrId || s.id.toString() === nameOrId);
+			if (!server) {
+				spinner.fail(chalk.red("MCP server not found"));
+				console.log(chalk.yellow(`\n⚠️  No MCP server found with name or ID: ${nameOrId}\n`));
+				return;
+			}
+			spinner.stop();
+			if (!(await prompts({
+				type: "confirm",
+				name: "confirm",
+				message: `Remove MCP server "${server.name}"?`,
+				initial: false
+			})).confirm) {
+				console.log(chalk.yellow("\n❌ Removal cancelled"));
+				return;
+			}
+			const deleteSpinner = ora("Removing MCP server...").start();
+			await apiClient$1.deleteMcpServer(server.id.toString());
+			await removeMcpServer(server.name);
+			deleteSpinner.succeed(chalk.green("MCP server removed successfully!"));
+			console.log();
+		} catch (error) {
+			spinner.fail(chalk.red("Failed to remove MCP server"));
+			console.error(chalk.red(`\n❌ ${error.message}`));
+			process.exit(1);
+		}
+	},
+	async start() {
+		await requireAuth();
+		await getActiveTeamId();
+		ora("Starting MCP server...").start();
+		await mcp_default();
+	}
+};
+
+//#endregion
+//#region src/commands/sync.ts
+async function syncCommand(options) {
+	await requireAuth();
+	await getActiveTeamId();
+	if (options.dryRun) console.log(chalk.bold("\n🔍 Dry Run Mode (no changes will be made)\n"));
+	else console.log(chalk.bold("\n🔄 Synchronizing Resources\n"));
+	if (options.dryRun) {
+		console.log(chalk.yellow("Dry run mode not yet implemented"));
+		console.log(chalk.gray("For now, sync will proceed with actual changes\n"));
+	}
+	try {
+		console.log(chalk.cyan("📥 Pulling subagents..."));
+		await subagentCommands.pull({ overwrite: false });
+		console.log(chalk.cyan("📥 Pulling MCP servers..."));
+		await mcpCommands.pull({ merge: true });
+		console.log(chalk.green.bold("\n✅ Sync completed successfully!\n"));
+	} catch (error) {
+		console.error(chalk.red("\n❌ Sync failed"));
+		console.error(chalk.red(`${error.message}\n`));
+		process.exit(1);
+	}
+}
+async function statusCommand() {
+	await requireAuth();
+	const teamId = await getActiveTeamId();
+	console.log(chalk.bold("\n📊 Sync Status\n"));
+	const spinner = ora("Checking status...").start();
+	try {
+		spinner.succeed(chalk.green("Status check complete"));
+		console.log(chalk.cyan(`Team ID: ${teamId}`));
+		console.log(chalk.white("\nTo see detailed status:"));
+		console.log(chalk.white("  • Run"), chalk.cyan("jive subagents list"), chalk.white("to view subagents"));
+		console.log(chalk.white("  • Run"), chalk.cyan("jive mcp list"), chalk.white("to view MCP servers"));
+		console.log(chalk.white("  • Run"), chalk.cyan("jive sync"), chalk.white("to synchronize\n"));
+	} catch (error) {
+		spinner.fail(chalk.red("Failed to check status"));
+		console.error(chalk.red(`\n❌ ${error.message}\n`));
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/commands/doctor.ts
+async function doctorCommand() {
+	console.log(chalk.bold("\n🩺 Jive Health Check\n"));
+	const results = [];
+	results.push({
+		name: "Authentication",
+		result: await checkAuthentication()
+	});
+	results.push({
+		name: "Project Initialization",
+		result: await checkProjectInit()
+	});
+	results.push({
+		name: "MCP Server Config",
+		result: await checkMcpConfig()
+	});
+	results.push({
+		name: "Subagent Runner",
+		result: await checkSubagentRunner()
+	});
+	results.push({
+		name: "Telemetry Plugin",
+		result: await checkPlugin()
+	});
+	results.push({
+		name: "Plugin Config",
+		result: await checkPluginConfig()
+	});
+	results.push({
+		name: "API Connectivity",
+		result: await checkApiConnectivity()
+	});
+	results.push({
+		name: "Team Membership",
+		result: await checkTeamMembership()
+	});
+	console.log(chalk.bold("Checks:\n"));
+	let passCount = 0;
+	let warnCount = 0;
+	let failCount = 0;
+	for (const { name, result } of results) {
+		const icon = result.status === "pass" ? "✓" : result.status === "warn" ? "⚠" : "✗";
+		const color = result.status === "pass" ? chalk.green : result.status === "warn" ? chalk.yellow : chalk.red;
+		console.log(color(`  ${icon} ${name}`));
+		console.log(color(`    ${result.message}`));
+		if (result.details) console.log(chalk.gray(`    ${result.details}`));
+		if (result.fix) console.log(chalk.cyan(`    Fix: ${result.fix}`));
+		console.log("");
+		if (result.status === "pass") passCount++;
+		if (result.status === "warn") warnCount++;
+		if (result.status === "fail") failCount++;
+	}
+	console.log(chalk.bold("Summary:\n"));
+	console.log(chalk.green(`  ${passCount} passed`));
+	if (warnCount > 0) console.log(chalk.yellow(`  ${warnCount} warnings`));
+	if (failCount > 0) console.log(chalk.red(`  ${failCount} failed`));
+	if (failCount === 0 && warnCount === 0) console.log(chalk.bold.green("\n✨ All checks passed! Jive is healthy.\n"));
+	else if (failCount === 0) console.log(chalk.bold.yellow("\n⚠️  Some warnings found, but system should work.\n"));
+	else {
+		console.log(chalk.bold.red("\n❌ Critical issues found. Please fix them to use Jive.\n"));
+		console.log(chalk.white("Run"), chalk.cyan("jive init"), chalk.white("to initialize or repair your setup.\n"));
+	}
+}
+async function checkAuthentication() {
+	const credentials = await getCredentials();
+	if (!credentials) return {
+		status: "fail",
+		message: "Not authenticated",
+		fix: "Run \"jive login\" to authenticate"
+	};
+	return {
+		status: "pass",
+		message: "Authenticated",
+		details: `Logged in as ${credentials.email}`
+	};
+}
+async function checkProjectInit() {
+	try {
+		const config = await getProjectConfig();
+		if (!config) return {
+			status: "fail",
+			message: "Project not initialized",
+			fix: "Run \"jive init\" to initialize this project"
+		};
+		return {
+			status: "pass",
+			message: "Project initialized",
+			details: `Team ID: ${config.teamId}`
+		};
+	} catch (error) {
+		return {
+			status: "fail",
+			message: "Cannot read project config",
+			details: error.message,
+			fix: "Run \"jive init\" to recreate configuration"
+		};
+	}
+}
+async function checkMcpConfig() {
+	const mcpConfig = await getMcpConfig();
+	if (!mcpConfig) return {
+		status: "fail",
+		message: "No .mcp.json found",
+		fix: "Run \"jive init\" to create .mcp.json"
+	};
+	if (!mcpConfig.mcpServers?.["jive-mcp"]) return {
+		status: "warn",
+		message: "Jive server not configured",
+		details: "Found .mcp.json but jive-mcp server is missing",
+		fix: "Run \"jive init\" to add jive-mcp server"
+	};
+	return {
+		status: "pass",
+		message: "MCP server configured",
+		details: `${Object.keys(mcpConfig.mcpServers || {}).length} server(s) configured`
+	};
+}
+async function checkSubagentRunner() {
+	const runnerPath = path.join(process.cwd(), ".claude", "agents", "subagent-runner.md");
+	try {
+		await fs.access(runnerPath);
+		if (!(await fs.readFile(runnerPath, "utf-8")).includes("subagent-runner")) return {
+			status: "warn",
+			message: "Subagent runner file corrupted",
+			details: "File exists but content is invalid",
+			fix: "Run \"jive init\" to recreate subagent-runner.md"
+		};
+		return {
+			status: "pass",
+			message: "Subagent runner exists",
+			details: runnerPath
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") return {
+			status: "fail",
+			message: "Subagent runner not found",
+			fix: "Run \"jive init\" to create .claude/agents/subagent-runner.md"
+		};
+		return {
+			status: "fail",
+			message: "Cannot read subagent runner",
+			details: error.message
+		};
+	}
+}
+async function checkPlugin() {
+	const pluginStatus = await getPluginStatus();
+	if (!pluginStatus.installed) return {
+		status: "warn",
+		message: "Telemetry plugin not installed",
+		details: "Subagent execution tracking will not work",
+		fix: "Run \"jive init\" to install the plugin, or see SUBAGENT_VISIBILITY.md"
+	};
+	try {
+		const pluginJsonPath = path.join(pluginStatus.pluginPath, ".claude-plugin", "plugin.json");
+		await fs.access(pluginJsonPath);
+		return {
+			status: "pass",
+			message: "Telemetry plugin installed",
+			details: pluginStatus.pluginPath
+		};
+	} catch {
+		return {
+			status: "warn",
+			message: "Plugin installation incomplete",
+			details: "Plugin directory exists but files are missing",
+			fix: "Run \"jive init\" to reinstall the plugin"
+		};
+	}
+}
+async function checkPluginConfig() {
+	const pluginStatus = await getPluginStatus();
+	if (!pluginStatus.configured) return {
+		status: "warn",
+		message: "Plugin not configured",
+		details: "Missing .jive/config.json with telemetry settings",
+		fix: "Run \"jive init\" to create plugin configuration"
+	};
+	try {
+		const configContent = await fs.readFile(pluginStatus.configPath, "utf-8");
+		const config = JSON.parse(configContent);
+		if (!config.apiUrl || !config.apiKey) return {
+			status: "warn",
+			message: "Plugin config incomplete",
+			details: "Missing apiUrl or apiKey",
+			fix: "Run \"jive init\" to recreate plugin configuration"
+		};
+		return {
+			status: "pass",
+			message: "Plugin configured",
+			details: `API: ${config.apiUrl}`
+		};
+	} catch (error) {
+		return {
+			status: "warn",
+			message: "Invalid plugin config",
+			details: error.message,
+			fix: "Run \"jive init\" to recreate plugin configuration"
+		};
+	}
+}
+async function checkApiConnectivity() {
+	if (!await getCredentials()) return {
+		status: "fail",
+		message: "Cannot check API (not authenticated)",
+		fix: "Run \"jive login\" first"
+	};
+	try {
+		await getApiClient().getTeams();
+		return {
+			status: "pass",
+			message: "API reachable",
+			details: `Successfully connected to Jive API`
+		};
+	} catch (error) {
+		return {
+			status: "fail",
+			message: "Cannot reach API",
+			details: error.message,
+			fix: "Check your internet connection and JIVE_API_URL environment variable"
+		};
+	}
+}
+async function checkTeamMembership() {
+	if (!await getCredentials()) return {
+		status: "fail",
+		message: "Cannot check teams (not authenticated)",
+		fix: "Run \"jive login\" first"
+	};
+	try {
+		const result = await getApiClient().getTeams();
+		if (result.teams.length === 0) return {
+			status: "warn",
+			message: "Not a member of any teams",
+			fix: "Run \"jive team create\" to create a team"
+		};
+		const teamNames = result.teams.map((t) => t.name).join(", ");
+		return {
+			status: "pass",
+			message: `Member of ${result.teams.length} team(s)`,
+			details: teamNames
+		};
+	} catch (error) {
+		return {
+			status: "fail",
+			message: "Cannot fetch teams",
+			details: error.message
+		};
+	}
+}
+
+//#endregion
+//#region src/index.ts
+const program = new Command();
+program.name("jive").description("CLI tool for managing MCP servers, tools, and subagents across teams").version("0.1.0");
+program.command("login").description("Authenticate with the Jive platform").action(loginCommand);
+program.command("signup").description("Create a new account").action(signupCommand);
+program.command("logout").description("Clear authentication credentials").action(logoutCommand);
+const team = program.command("team").description("Manage teams");
+team.command("create").description("Create a new team").action(teamCommands.create);
+team.command("list").description("List all teams you're a member of").action(teamCommands.list);
+team.command("switch").description("Switch active team context").action(teamCommands.switch);
+team.command("invite").description("Invite user to current team").argument("<email>", "Email address of user to invite").action(teamCommands.invite);
+program.command("init").description("Initialize Jive in current project").action(initCommand);
+program.command("detach").description("Remove Jive integrations from current project").action(detachCommand);
+program.command("doctor").description("Check Jive installation and configuration").action(doctorCommand);
+const subagents = program.command("subagents").description("Manage subagents");
+subagents.command("list").description("List all subagents for active team").action(subagentCommands.list);
+subagents.command("pull").description("Download team subagents to local .claude/agents/ directory").option("--overwrite", "Overwrite existing files").action(subagentCommands.pull);
+subagents.command("push").description("Upload local subagents to team").option("--force", "Force push without conflict checks").option("-m, --message <text>", "Change description for version history").action(subagentCommands.push);
+subagents.command("create").description("Create a new subagent interactively").action(subagentCommands.create);
+subagents.command("delete").description("Delete a subagent").argument("<name-or-id>", "Name or ID of subagent to delete").action(subagentCommands.delete);
+const mcp = program.command("mcp").description("Manage MCP servers");
+mcp.command("list").description("List all MCP servers for active team").action(mcpCommands.list);
+mcp.command("pull").description("Download team MCP servers to local .mcp.json").option("--merge", "Merge with local servers instead of replacing").action(mcpCommands.pull);
+mcp.command("push").description("Upload local MCP servers to team").option("--force", "Force push without conflict checks").action(mcpCommands.push);
+mcp.command("add").description("Add a new MCP server to team").argument("<name>", "Name of the MCP server").action(mcpCommands.add);
+mcp.command("remove").description("Remove an MCP server from team").argument("<name-or-id>", "Name or ID of MCP server to remove").action(mcpCommands.remove);
+mcp.command("start").description("Start the MCP server").action(mcpCommands.start);
+program.command("sync").description("Synchronize all resources between local and team").option("--dry-run", "Show what would be changed without making changes").action(syncCommand);
+program.command("status").description("Show sync status of local resources").action(statusCommand);
+program.parse();
+
+//#endregion
+export { isProjectInitialized as a, saveCredentials as c, getProjectConfig as i, saveProjectConfig as l, getActiveTeamId as n, requireAuth as o, getCredentials as r, requireProjectConfig as s, clearCredentials as t, updateProjectConfig as u };