@jive-ai/cli 0.0.3 → 0.0.5

package/dist/index.mjs

@@ -567,172 +567,6 @@ async function addToGitignore(pattern) {
 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;
@@ -811,7 +645,9 @@ async function initCommand() {
 	try {
 		spinner.text = "Scanning for existing MCP servers...";
 		const mcpConfig = await getMcpConfig();
-		let uploadedServers = 0;
+		const currentMcpServers = await apiClient$1.getMcpServers(teamId);
+		let uploadedServers = [];
+		let skippedServers = [];
 		if (mcpConfig?.mcpServers) {
 			const serverNames = Object.keys(mcpConfig.mcpServers).filter((name) => name !== "jive-mcp");
 			if (serverNames.length > 0) {
@@ -819,12 +655,21 @@ async function initCommand() {
 				for (const name of serverNames) {
 					const serverConfig = mcpConfig.mcpServers[name];
 					try {
-						await apiClient$1.createMcpServer(teamId, {
+						if (currentMcpServers.some((s) => s.name === name)) skippedServers.push({
 							name,
-							description: `Imported from local .mcp.json`,
-							config: serverConfig
+							id: currentMcpServers.find((s) => s.name === name)?.id || ""
 						});
-						uploadedServers++;
+						else {
+							const created = await apiClient$1.createMcpServer(teamId, {
+								name,
+								description: `Imported from local .mcp.json`,
+								config: serverConfig
+							});
+							uploadedServers.push({
+								name,
+								id: created.id
+							});
+						}
 					} catch (error) {
 						console.warn(chalk.gray(`\nWarning: Could not upload MCP server "${name}": ${error.message}`));
 					}
@@ -833,19 +678,30 @@ async function initCommand() {
 		}
 		spinner.text = "Scanning for existing subagents...";
 		const subagentFiles = await getSubagentFiles();
-		let uploadedSubagents = 0;
+		const currentSubagents = await apiClient$1.getSubagents(teamId);
+		let uploadedSubagents = [];
+		let skippedSubagents = [];
 		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, {
+					if (currentSubagents.some((s) => s.name === subagent.name)) skippedSubagents.push({
 						name: subagent.name,
-						description: subagent.description,
-						prompt: subagent.prompt
+						id: currentSubagents.find((s) => s.name === subagent.name)?.id || ""
 					});
-					await updateSubagentJiveId(subagent.name, created.id);
-					uploadedSubagents++;
+					else {
+						const created = await apiClient$1.createSubagent(teamId, {
+							name: subagent.name,
+							description: subagent.description,
+							prompt: subagent.prompt
+						});
+						await updateSubagentJiveId(subagent.name, created.id);
+						uploadedSubagents.push({
+							name: subagent.name,
+							id: created.id
+						});
+					}
 				} catch (error) {
 					console.warn(chalk.gray(`\nWarning: Could not upload subagent "${subagent.name}": ${error.message}`));
 				}
@@ -853,59 +709,40 @@ async function initCommand() {
 		}
 		spinner.text = "Adding Jive server to .mcp.json...";
 		await addMcpServer("jive-mcp", {
-			command: "npx",
-			args: ["-y", "@jive/mcp-server"],
+			command: "jive mcp start",
 			env: {
-				JIVE_API_URL: process.env.JIVE_API_URL || "http://localhost:5173",
 				JIVE_TEAM_ID: teamId,
 				JIVE_AUTH_TOKEN: credentials.token
 			}
 		});
+		spinner.text = "Removing uploaded MCP servers from local .mcp.json...";
+		if (mcpConfig?.mcpServers) {
+			for (const name of Object.keys(mcpConfig.mcpServers)) if (uploadedSubagents.some((subagent) => subagent.name === name)) await removeMcpServer(name);
+		}
 		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/");
+		await addToGitignore(".jive");
 		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"));
+		if (uploadedServers.length > 0) console.log(chalk.green(`  ✓ Uploaded ${uploadedServers.length} MCP server(s) to team`));
+		if (skippedServers.length > 0) console.log(chalk.yellow(`  ⚠ Skipped ${skippedServers.length} MCP server(s) (already exist)`));
+		if (uploadedSubagents.length > 0) console.log(chalk.green(`  ✓ Uploaded ${uploadedSubagents.length} subagent(s) to team`));
+		if (skippedSubagents.length > 0) console.log(chalk.yellow(`  ⚠ Skipped ${skippedSubagents.length} subagent(s) (already exist)`));
+		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("  • Restart Claude Code to load the Jive MCP server"));
 		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"}`));

package/docs/auth.md

@@ -0,0 +1,378 @@
+# Authentication Commands
+
+Jive CLI requires authentication to access team resources and collaborate with team members. This guide covers all authentication-related commands.
+
+## Overview
+
+Authentication in Jive uses token-based authentication. After logging in or signing up, your credentials are securely stored in `~/.jive/credentials.json` with restricted file permissions (mode 0600).
+
+## Commands
+
+### `jive signup`
+
+Create a new Jive account.
+
+**Usage:**
+```bash
+jive signup
+```
+
+**Interactive Prompts:**
+- **Email:** Your email address for account registration
+- **Password:** Account password (minimum 8 characters)
+- **Confirm Password:** Re-enter password for verification
+
+**Process:**
+1. Prompts for email and password
+2. Validates password requirements (minimum 8 characters)
+3. Calls the Jive API signup endpoint (`/api/auth/signup`)
+4. Automatically saves authentication credentials
+5. Displays success message with suggested next steps
+
+**Output:**
+```
+Account created successfully!
+Credentials saved to /Users/username/.jive/credentials.json
+
+Next steps:
+1. Create a team: jive team create
+2. Initialize Jive in your project: jive init
+```
+
+**Credentials Stored:**
+```json
+{
+  "token": "auth-token-here",
+  "userId": "user-123",
+  "email": "user@example.com"
+}
+```
+
+**Error Conditions:**
+- Email already registered
+- Password too short (< 8 characters)
+- Passwords don't match
+- Network connectivity issues
+
+**Implementation:** `src/commands/auth.ts` (signupCommand)
+
+---
+
+### `jive login`
+
+Authenticate with an existing Jive account.
+
+**Usage:**
+```bash
+jive login
+```
+
+**Interactive Prompts:**
+- **Email:** Your registered email address
+- **Password:** Your account password
+
+**Process:**
+1. Prompts for email and password
+2. Calls the Jive API login endpoint (`/api/auth/login`)
+3. Saves authentication credentials to `~/.jive/credentials.json`
+4. Sets file permissions to 0600 (read/write for owner only)
+
+**Output:**
+```
+Login successful!
+Credentials saved to /Users/username/.jive/credentials.json
+```
+
+**Credentials Stored:**
+```json
+{
+  "token": "auth-token-here",
+  "userId": "user-123",
+  "email": "user@example.com"
+}
+```
+
+**Error Conditions:**
+- Invalid email or password
+- Account not found
+- Network connectivity issues
+- API server unavailable
+
+**Security Notes:**
+- Credentials file is created with mode 0600 (only readable by owner)
+- Never share your credentials file
+- The authentication token is used for all API requests
+
+**Implementation:** `src/commands/auth.ts` (loginCommand)
+
+---
+
+### `jive logout`
+
+Clear authentication credentials and log out.
+
+**Usage:**
+```bash
+jive logout
+```
+
+**Interactive Prompts:**
+- **Confirmation:** "Are you sure you want to logout?" (Y/n)
+
+**Process:**
+1. Checks if user is currently logged in
+2. Prompts for confirmation
+3. Deletes `~/.jive/credentials.json` file
+4. Displays success message
+
+**Output:**
+```
+Logged out successfully
+```
+
+**Notes:**
+- This only removes local credentials; it doesn't invalidate the token on the server
+- You can log back in at any time with `jive login`
+- Active team configurations in projects remain intact
+
+**Error Conditions:**
+- Not currently logged in (displays "Not logged in" message)
+- User cancels confirmation
+
+**Implementation:** `src/commands/auth.ts` (logoutCommand)
+
+---
+
+## Authentication Flow
+
+### First-Time Setup
+
+1. **Sign up for an account:**
+   ```bash
+   jive signup
+   ```
+
+2. **Create or join a team:**
+   ```bash
+   jive team create
+   ```
+   Or accept an email invitation to join an existing team.
+
+3. **Initialize in a project:**
+   ```bash
+   jive init
+   ```
+
+### Returning User
+
+1. **Log in:**
+   ```bash
+   jive login
+   ```
+
+2. **Start using Jive commands:**
+   ```bash
+   jive team list
+   jive subagents pull
+   jive mcp pull
+   ```
+
+## Credentials Storage
+
+### Location
+
+Credentials are stored in:
+```
+~/.jive/credentials.json
+```
+
+**Absolute paths:**
+- macOS/Linux: `/Users/username/.jive/credentials.json`
+- Windows: `C:\Users\username\.jive\credentials.json`
+
+### Format
+
+```json
+{
+  "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+  "userId": "user-abc123",
+  "email": "user@example.com"
+}
+```
+
+### Security
+
+- File permissions set to 0600 (owner read/write only)
+- Token is used in `X-API-Key` header for all API requests
+- Automatically injected by the API client
+
+**Never commit credentials to version control!**
+
+## API Integration
+
+### Authentication Header
+
+All authenticated requests include:
+```http
+X-API-Key: <token-from-credentials>
+```
+
+### Token Handling
+
+The API client (`src/lib/api-client.ts`) automatically:
+- Reads credentials from `~/.jive/credentials.json`
+- Injects the `X-API-Key` header
+- Handles 401 Unauthorized responses by prompting re-authentication
+
+### Session Management
+
+- Tokens do not expire (currently)
+- If you receive authentication errors, try logging out and back in:
+  ```bash
+  jive logout
+  jive login
+  ```
+
+## Troubleshooting
+
+### "Not authenticated" Error
+
+**Symptom:** Commands fail with "Please login first: jive login"
+
+**Solutions:**
+1. Check if credentials file exists:
+   ```bash
+   ls ~/.jive/credentials.json
+   ```
+
+2. Log in again:
+   ```bash
+   jive login
+   ```
+
+3. If signup is needed:
+   ```bash
+   jive signup
+   ```
+
+### "Invalid credentials" Error
+
+**Symptom:** Login fails with incorrect email/password
+
+**Solutions:**
+1. Verify email address is correct
+2. Reset password (if password reset is implemented)
+3. Sign up for a new account if needed:
+   ```bash
+   jive signup
+   ```
+
+### Credentials File Missing
+
+**Symptom:** `~/.jive/credentials.json` doesn't exist
+
+**Solutions:**
+1. Log in to recreate the file:
+   ```bash
+   jive login
+   ```
+
+2. Check file permissions:
+   ```bash
+   ls -la ~/.jive/credentials.json
+   ```
+   Should show `-rw-------` (0600 permissions)
+
+### 401 Unauthorized Errors
+
+**Symptom:** API requests fail with 401 status
+
+**Solutions:**
+1. Log out and log back in:
+   ```bash
+   jive logout
+   jive login
+   ```
+
+2. Verify credentials are valid:
+   ```bash
+   cat ~/.jive/credentials.json
+   ```
+
+3. Check API connectivity:
+   ```bash
+   jive doctor
+   ```
+
+## Environment Variables
+
+### `JIVE_API_URL`
+
+Override the default API URL:
+
+```bash
+export JIVE_API_URL=https://your-custom-api.com
+jive login
+```
+
+**Default:** `https://next.getjive.app`
+
+This affects all API endpoints:
+- `/api/auth/login`
+- `/api/auth/signup`
+- `/api/teams/*`
+- `/api/subagents/*`
+- `/api/mcp-servers/*`
+
+## Security Best Practices
+
+1. **Never share your credentials file**
+   - Don't commit to version control
+   - Don't share via chat or email
+   - Don't copy to shared locations
+
+2. **Use strong passwords**
+   - Minimum 8 characters (enforced)
+   - Mix of letters, numbers, and symbols (recommended)
+   - Unique password for Jive (recommended)
+
+3. **Protect your credentials file**
+   - File permissions are automatically set to 0600
+   - Don't modify permissions to make it world-readable
+   - Keep backups secure
+
+4. **Log out when done**
+   - On shared machines, always log out:
+     ```bash
+     jive logout
+     ```
+
+5. **Monitor access**
+   - Review team member list regularly
+   - Remove users who no longer need access
+
+## Related Commands
+
+- [`jive team create`](./team.md#jive-team-create) - Create a team after signup
+- [`jive team list`](./team.md#jive-team-list) - List teams (requires authentication)
+- [`jive init`](./init.md#jive-init) - Initialize project (requires authentication)
+- [`jive doctor`](./init.md#jive-doctor) - Verify authentication and setup
+
+## Implementation Details
+
+**Source Files:**
+- Main implementation: `src/commands/auth.ts`
+- Configuration helpers: `src/lib/config.ts`
+- API client: `src/lib/api-client.ts`
+
+**Key Functions:**
+- `signupCommand()` - Handles user registration
+- `loginCommand()` - Handles user authentication
+- `logoutCommand()` - Clears credentials
+- `loadCredentials()` - Reads credentials file
+- `saveCredentials()` - Writes credentials file securely
+- `requireAuth()` - Ensures user is authenticated (exits if not)
+
+**API Endpoints:**
+- `POST /api/auth/signup` - Create new account
+- `POST /api/auth/login` - Authenticate existing account