claudeup 1.7.0 → 3.3.0

package/{dist → src}/services/plugin-mcp-config.js

@@ -1,30 +1,32 @@
-import fs from 'fs-extra';
-import path from 'node:path';
-import os from 'node:os';
-const CLAUDE_PLUGINS_DIR = path.join(os.homedir(), '.claude', 'plugins', 'marketplaces');
+import fs from "fs-extra";
+import path from "node:path";
+import os from "node:os";
+const CLAUDE_PLUGINS_DIR = path.join(os.homedir(), ".claude", "plugins", "marketplaces");
 /**
  * Extract ${VAR_NAME} patterns from a value
  * @param value - The value to search for env var references
  * @returns Array of env var names found
  */
 function extractEnvVarReferences(value) {
-    if (typeof value !== 'string')
+    if (typeof value !== "string")
         return [];
     const matches = value.match(/\$\{([A-Z_][A-Z0-9_]*)\}/g);
     if (!matches)
         return [];
-    return matches.map(match => {
+    return matches
+        .map((match) => {
         // Extract VAR_NAME from ${VAR_NAME}
         const innerMatch = match.match(/\$\{([A-Z_][A-Z0-9_]*)\}/);
-        return innerMatch ? innerMatch[1] : '';
-    }).filter(Boolean);
+        return innerMatch ? innerMatch[1] : "";
+    })
+        .filter(Boolean);
 }
 /**
  * Recursively extract all env var references from an object
  */
 function extractAllEnvVarReferences(obj) {
     const vars = [];
-    if (typeof obj === 'string') {
+    if (typeof obj === "string") {
         vars.push(...extractEnvVarReferences(obj));
     }
     else if (Array.isArray(obj)) {
@@ -32,7 +34,7 @@ function extractAllEnvVarReferences(obj) {
             vars.push(...extractAllEnvVarReferences(item));
         }
     }
-    else if (obj && typeof obj === 'object') {
+    else if (obj && typeof obj === "object") {
         for (const value of Object.values(obj)) {
             vars.push(...extractAllEnvVarReferences(value));
         }
@@ -49,8 +51,8 @@ function getPluginMcpConfigPath(marketplaceName, pluginSource) {
     if (!pluginSource)
         return undefined;
     const marketplacePath = path.join(CLAUDE_PLUGINS_DIR, marketplaceName);
-    const pluginPath = path.join(marketplacePath, pluginSource.replace(/^\.\//, ''));
-    const mcpConfigPath = path.join(pluginPath, 'mcp-servers', 'mcp-config.json');
+    const pluginPath = path.join(marketplacePath, pluginSource.replace(/^\.\//, ""));
+    const mcpConfigPath = path.join(pluginPath, "mcp-servers", "mcp-config.json");
     return mcpConfigPath;
 }
 /**
@@ -69,7 +71,7 @@ export async function readPluginMcpConfig(marketplaceName, pluginSource) {
             // Filter out comment fields (keys starting with _)
             const filtered = {};
             for (const [key, value] of Object.entries(content)) {
-                if (!key.startsWith('_') && value && typeof value === 'object') {
+                if (!key.startsWith("_") && value && typeof value === "object") {
                     filtered[key] = value;
                 }
             }
@@ -88,9 +90,9 @@ export async function readPluginMcpConfig(marketplaceName, pluginSource) {
  */
 function generateLabel(varName) {
     return varName
-        .split('_')
-        .map(word => word.charAt(0) + word.slice(1).toLowerCase())
-        .join(' ');
+        .split("_")
+        .map((word) => word.charAt(0) + word.slice(1).toLowerCase())
+        .join(" ");
 }
 /**
  * Get all environment variable requirements for a plugin
@@ -148,7 +150,7 @@ export async function getPluginEnvRequirements(marketplaceName, pluginSource) {
  */
 export async function getPluginSourcePath(marketplaceName, pluginName) {
     const marketplacePath = path.join(CLAUDE_PLUGINS_DIR, marketplaceName);
-    const manifestPath = path.join(marketplacePath, '.claude-plugin', 'marketplace.json');
+    const manifestPath = path.join(marketplacePath, ".claude-plugin", "marketplace.json");
     try {
         if (await fs.pathExists(manifestPath)) {
             const manifest = await fs.readJson(manifestPath);
@@ -173,4 +175,3 @@ export async function getPluginMcpServerNames(marketplaceName, pluginSource) {
     const mcpConfig = await readPluginMcpConfig(marketplaceName, pluginSource);
     return Object.keys(mcpConfig);
 }
-//# sourceMappingURL=plugin-mcp-config.js.map

package/src/services/plugin-mcp-config.ts

@@ -0,0 +1,242 @@
+import fs from "fs-extra";
+import path from "node:path";
+import os from "node:os";
+
+const CLAUDE_PLUGINS_DIR = path.join(
+	os.homedir(),
+	".claude",
+	"plugins",
+	"marketplaces",
+);
+
+/**
+ * Represents a required environment variable for a plugin's MCP server
+ */
+export interface PluginEnvRequirement {
+	/** The environment variable name (e.g., "FIGMA_ACCESS_TOKEN") */
+	name: string;
+	/** User-friendly label (defaults to name if not provided) */
+	label: string;
+	/** The MCP server name this env var is for */
+	serverName: string;
+	/** Whether this env var is required (all detected vars are considered required) */
+	required: boolean;
+}
+
+/**
+ * Extract ${VAR_NAME} patterns from a value
+ * @param value - The value to search for env var references
+ * @returns Array of env var names found
+ */
+function extractEnvVarReferences(value: unknown): string[] {
+	if (typeof value !== "string") return [];
+
+	const matches = value.match(/\$\{([A-Z_][A-Z0-9_]*)\}/g);
+	if (!matches) return [];
+
+	return matches
+		.map((match) => {
+			// Extract VAR_NAME from ${VAR_NAME}
+			const innerMatch = match.match(/\$\{([A-Z_][A-Z0-9_]*)\}/);
+			return innerMatch ? innerMatch[1] : "";
+		})
+		.filter(Boolean);
+}
+
+/**
+ * Recursively extract all env var references from an object
+ */
+function extractAllEnvVarReferences(obj: unknown): string[] {
+	const vars: string[] = [];
+
+	if (typeof obj === "string") {
+		vars.push(...extractEnvVarReferences(obj));
+	} else if (Array.isArray(obj)) {
+		for (const item of obj) {
+			vars.push(...extractAllEnvVarReferences(item));
+		}
+	} else if (obj && typeof obj === "object") {
+		for (const value of Object.values(obj)) {
+			vars.push(...extractAllEnvVarReferences(value));
+		}
+	}
+
+	return vars;
+}
+
+interface McpServerConfig {
+	command?: string;
+	args?: string[];
+	env?: Record<string, string>;
+	type?: "http";
+	url?: string;
+}
+
+/**
+ * Get the path to a plugin's mcp-config.json in the marketplace cache
+ * @param marketplaceName - Name of the marketplace (e.g., "mag-claude-plugins")
+ * @param pluginSource - Plugin source path from marketplace.json (e.g., "./plugins/frontend")
+ * @returns Full path to mcp-config.json or undefined if not found
+ */
+function getPluginMcpConfigPath(
+	marketplaceName: string,
+	pluginSource?: string,
+): string | undefined {
+	if (!pluginSource) return undefined;
+
+	const marketplacePath = path.join(CLAUDE_PLUGINS_DIR, marketplaceName);
+	const pluginPath = path.join(
+		marketplacePath,
+		pluginSource.replace(/^\.\//, ""),
+	);
+	const mcpConfigPath = path.join(pluginPath, "mcp-servers", "mcp-config.json");
+
+	return mcpConfigPath;
+}
+
+/**
+ * Read and parse a plugin's MCP configuration
+ * @param marketplaceName - Name of the marketplace
+ * @param pluginSource - Plugin source path from marketplace.json
+ * @returns Parsed MCP config or empty object if not found
+ */
+export async function readPluginMcpConfig(
+	marketplaceName: string,
+	pluginSource?: string,
+): Promise<Record<string, McpServerConfig>> {
+	const configPath = getPluginMcpConfigPath(marketplaceName, pluginSource);
+	if (!configPath) return {};
+
+	try {
+		if (await fs.pathExists(configPath)) {
+			const content = await fs.readJson(configPath);
+			// Filter out comment fields (keys starting with _)
+			const filtered: Record<string, McpServerConfig> = {};
+			for (const [key, value] of Object.entries(content)) {
+				if (!key.startsWith("_") && value && typeof value === "object") {
+					filtered[key] = value as McpServerConfig;
+				}
+			}
+			return filtered;
+		}
+	} catch (error) {
+		console.error(`Failed to read plugin MCP config: ${error}`);
+	}
+
+	return {};
+}
+
+/**
+ * Generate user-friendly label from env var name
+ * @param varName - Environment variable name (e.g., "FIGMA_ACCESS_TOKEN")
+ * @returns Human-readable label (e.g., "Figma Access Token")
+ */
+function generateLabel(varName: string): string {
+	return varName
+		.split("_")
+		.map((word) => word.charAt(0) + word.slice(1).toLowerCase())
+		.join(" ");
+}
+
+/**
+ * Get all environment variable requirements for a plugin
+ * Extracts ${VAR_NAME} patterns from the plugin's mcp-config.json
+ *
+ * @param marketplaceName - Name of the marketplace (e.g., "mag-claude-plugins")
+ * @param pluginSource - Plugin source path from marketplace.json (e.g., "./plugins/frontend")
+ * @returns Array of required env vars with metadata
+ */
+export async function getPluginEnvRequirements(
+	marketplaceName: string,
+	pluginSource?: string,
+): Promise<PluginEnvRequirement[]> {
+	const mcpConfig = await readPluginMcpConfig(marketplaceName, pluginSource);
+	const requirements: PluginEnvRequirement[] = [];
+	const seenVars = new Set<string>();
+
+	for (const [serverName, config] of Object.entries(mcpConfig)) {
+		// Extract from env object
+		if (config.env) {
+			for (const value of Object.values(config.env)) {
+				const vars = extractEnvVarReferences(value);
+				for (const varName of vars) {
+					if (!seenVars.has(varName)) {
+						seenVars.add(varName);
+						requirements.push({
+							name: varName,
+							label: generateLabel(varName),
+							serverName,
+							required: true,
+						});
+					}
+				}
+			}
+		}
+
+		// Also check args array for env var references (e.g., sqlite with ${DATABASE_PATH})
+		if (config.args) {
+			const argsVars = extractAllEnvVarReferences(config.args);
+			for (const varName of argsVars) {
+				if (!seenVars.has(varName)) {
+					seenVars.add(varName);
+					requirements.push({
+						name: varName,
+						label: generateLabel(varName),
+						serverName,
+						required: true,
+					});
+				}
+			}
+		}
+	}
+
+	return requirements;
+}
+
+/**
+ * Get plugin source path from local marketplace cache
+ * @param marketplaceName - Name of the marketplace
+ * @param pluginName - Name of the plugin
+ * @returns Plugin source path or undefined
+ */
+export async function getPluginSourcePath(
+	marketplaceName: string,
+	pluginName: string,
+): Promise<string | undefined> {
+	const marketplacePath = path.join(CLAUDE_PLUGINS_DIR, marketplaceName);
+	const manifestPath = path.join(
+		marketplacePath,
+		".claude-plugin",
+		"marketplace.json",
+	);
+
+	try {
+		if (await fs.pathExists(manifestPath)) {
+			const manifest = await fs.readJson(manifestPath);
+			if (manifest.plugins && Array.isArray(manifest.plugins)) {
+				const plugin = manifest.plugins.find(
+					(p: { name: string }) => p.name === pluginName,
+				);
+				return plugin?.source;
+			}
+		}
+	} catch {
+		// Return undefined if can't read
+	}
+
+	return undefined;
+}
+
+/**
+ * Get all MCP server names from a plugin's config
+ * @param marketplaceName - Name of the marketplace
+ * @param pluginSource - Plugin source path
+ * @returns Array of MCP server names
+ */
+export async function getPluginMcpServerNames(
+	marketplaceName: string,
+	pluginSource?: string,
+): Promise<string[]> {
+	const mcpConfig = await readPluginMcpConfig(marketplaceName, pluginSource);
+	return Object.keys(mcpConfig);
+}

package/{dist → src}/services/update-cache.js

@@ -1,12 +1,12 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import os from "node:os";
 const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
 export class UpdateCache {
     cachePath;
     constructor() {
         // Cache at ~/.claude/claudeup-cache.json
-        this.cachePath = path.join(os.homedir(), '.claude', 'claudeup-cache.json');
+        this.cachePath = path.join(os.homedir(), ".claude", "claudeup-cache.json");
     }
     async shouldCheckForUpdates() {
         const data = await this.getLastCheck();
@@ -19,7 +19,7 @@ export class UpdateCache {
     }
     async getLastCheck() {
         try {
-            const content = await fs.readFile(this.cachePath, 'utf-8');
+            const content = await fs.readFile(this.cachePath, "utf-8");
             const data = JSON.parse(content);
             return data;
         }
@@ -34,11 +34,11 @@ export class UpdateCache {
             const cacheDir = path.dirname(this.cachePath);
             await fs.mkdir(cacheDir, { recursive: true });
             // Write cache file
-            await fs.writeFile(this.cachePath, JSON.stringify(result, null, 2), 'utf-8');
+            await fs.writeFile(this.cachePath, JSON.stringify(result, null, 2), "utf-8");
         }
         catch (error) {
             // Non-fatal - just log and continue
-            console.warn('Warning: Failed to save update cache:', error instanceof Error ? error.message : 'Unknown error');
+            console.warn("Warning: Failed to save update cache:", error instanceof Error ? error.message : "Unknown error");
         }
     }
     async clear() {
@@ -50,4 +50,3 @@ export class UpdateCache {
         }
     }
 }
-//# sourceMappingURL=update-cache.js.map

package/src/services/update-cache.ts

@@ -0,0 +1,78 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+
+export interface UpdateCacheData {
+	lastUpdateCheck: string; // ISO timestamp
+	lastUpdateResult: {
+		updated: string[]; // ["frontend@mag-claude-plugins v3.13.0", ...]
+		failed: string[]; // Marketplaces that failed
+		autoUpdated?: Array<{
+			pluginId: string;
+			oldVersion: string;
+			newVersion: string;
+		}>; // Plugins that were auto-updated
+	};
+}
+
+export class UpdateCache {
+	private cachePath: string;
+
+	constructor() {
+		// Cache at ~/.claude/claudeup-cache.json
+		this.cachePath = path.join(os.homedir(), ".claude", "claudeup-cache.json");
+	}
+
+	async shouldCheckForUpdates(): Promise<boolean> {
+		const data = await this.getLastCheck();
+		if (!data) return true; // No cache
+
+		const lastCheck = new Date(data.lastUpdateCheck);
+		const now = new Date();
+		const elapsed = now.getTime() - lastCheck.getTime();
+
+		return elapsed >= CACHE_TTL_MS;
+	}
+
+	async getLastCheck(): Promise<UpdateCacheData | null> {
+		try {
+			const content = await fs.readFile(this.cachePath, "utf-8");
+			const data = JSON.parse(content) as UpdateCacheData;
+			return data;
+		} catch (error) {
+			// Cache doesn't exist or is corrupted
+			return null;
+		}
+	}
+
+	async saveCheck(result: UpdateCacheData): Promise<void> {
+		try {
+			// Ensure .claude directory exists
+			const cacheDir = path.dirname(this.cachePath);
+			await fs.mkdir(cacheDir, { recursive: true });
+
+			// Write cache file
+			await fs.writeFile(
+				this.cachePath,
+				JSON.stringify(result, null, 2),
+				"utf-8",
+			);
+		} catch (error) {
+			// Non-fatal - just log and continue
+			console.warn(
+				"Warning: Failed to save update cache:",
+				error instanceof Error ? error.message : "Unknown error",
+			);
+		}
+	}
+
+	async clear(): Promise<void> {
+		try {
+			await fs.unlink(this.cachePath);
+		} catch (error) {
+			// Ignore errors (file might not exist)
+		}
+	}
+}

package/{dist → src}/services/version-check.js

@@ -1,5 +1,5 @@
-import { createRequire } from 'node:module';
-import semver from 'semver';
+import { createRequire } from "node:module";
+import semver from "semver";
 const require = createRequire(import.meta.url);
 // Cache the result for the session
 let cachedResult = null;
@@ -8,11 +8,11 @@ let cachedResult = null;
  */
 export function getCurrentVersion() {
     try {
-        const pkg = require('../../package.json');
+        const pkg = require("../../package.json");
         return pkg.version;
     }
     catch {
-        return '0.0.0';
+        return "0.0.0";
     }
 }
 /**
@@ -23,17 +23,17 @@ async function fetchLatestVersion() {
     try {
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), 3000); // 3s timeout
-        const response = await fetch('https://registry.npmjs.org/claudeup/latest', {
+        const response = await fetch("https://registry.npmjs.org/claudeup/latest", {
             signal: controller.signal,
             headers: {
-                'Accept': 'application/json',
+                Accept: "application/json",
             },
         });
         clearTimeout(timeout);
         if (!response.ok) {
             return null;
         }
-        const data = await response.json();
+        const data = (await response.json());
         return data.version || null;
     }
     catch {
@@ -50,11 +50,11 @@ function getUpdateType(current, latest) {
     if (!currentParsed || !latestParsed)
         return undefined;
     if (latestParsed.major > currentParsed.major)
-        return 'major';
+        return "major";
     if (latestParsed.minor > currentParsed.minor)
-        return 'minor';
+        return "minor";
     if (latestParsed.patch > currentParsed.patch)
-        return 'patch';
+        return "patch";
     return undefined;
 }
 /**
@@ -82,7 +82,9 @@ export async function checkForUpdates() {
         currentVersion,
         latestVersion,
         updateAvailable,
-        updateType: updateAvailable ? getUpdateType(currentVersion, latestVersion) : undefined,
+        updateType: updateAvailable
+            ? getUpdateType(currentVersion, latestVersion)
+            : undefined,
     };
     return cachedResult;
 }
@@ -91,8 +93,7 @@ export async function checkForUpdates() {
  */
 export function formatUpdateMessage(result) {
     if (!result.updateAvailable)
-        return '';
-    const typeLabel = result.updateType ? ` (${result.updateType})` : '';
+        return "";
+    const typeLabel = result.updateType ? ` (${result.updateType})` : "";
     return `Update available: v${result.currentVersion} → v${result.latestVersion}${typeLabel}. Run: npm i -g claudeup`;
 }
-//# sourceMappingURL=version-check.js.map

package/src/services/version-check.ts

@@ -0,0 +1,122 @@
+import { createRequire } from "node:module";
+import semver from "semver";
+
+const require = createRequire(import.meta.url);
+
+// Cache the result for the session
+let cachedResult: VersionCheckResult | null = null;
+
+export interface VersionCheckResult {
+	currentVersion: string;
+	latestVersion: string;
+	updateAvailable: boolean;
+	updateType?: "major" | "minor" | "patch";
+}
+
+/**
+ * Get the current version from package.json
+ */
+export function getCurrentVersion(): string {
+	try {
+		const pkg = require("../../package.json");
+		return pkg.version;
+	} catch {
+		return "0.0.0";
+	}
+}
+
+/**
+ * Fetch the latest version from npm registry
+ * Uses a short timeout to avoid blocking startup
+ */
+async function fetchLatestVersion(): Promise<string | null> {
+	try {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), 3000); // 3s timeout
+
+		const response = await fetch("https://registry.npmjs.org/claudeup/latest", {
+			signal: controller.signal,
+			headers: {
+				Accept: "application/json",
+			},
+		});
+
+		clearTimeout(timeout);
+
+		if (!response.ok) {
+			return null;
+		}
+
+		const data = (await response.json()) as { version?: string };
+		return data.version || null;
+	} catch {
+		// Network error, timeout, or parse error - silently fail
+		return null;
+	}
+}
+
+/**
+ * Determine the type of update (major, minor, patch)
+ */
+function getUpdateType(
+	current: string,
+	latest: string,
+): "major" | "minor" | "patch" | undefined {
+	const currentParsed = semver.parse(current);
+	const latestParsed = semver.parse(latest);
+
+	if (!currentParsed || !latestParsed) return undefined;
+
+	if (latestParsed.major > currentParsed.major) return "major";
+	if (latestParsed.minor > currentParsed.minor) return "minor";
+	if (latestParsed.patch > currentParsed.patch) return "patch";
+
+	return undefined;
+}
+
+/**
+ * Check if a new version is available
+ * Returns cached result if already checked this session
+ */
+export async function checkForUpdates(): Promise<VersionCheckResult> {
+	// Return cached result if available
+	if (cachedResult) {
+		return cachedResult;
+	}
+
+	const currentVersion = getCurrentVersion();
+	const latestVersion = await fetchLatestVersion();
+
+	if (!latestVersion) {
+		// Couldn't fetch, assume no update
+		cachedResult = {
+			currentVersion,
+			latestVersion: currentVersion,
+			updateAvailable: false,
+		};
+		return cachedResult;
+	}
+
+	const updateAvailable = semver.gt(latestVersion, currentVersion);
+
+	cachedResult = {
+		currentVersion,
+		latestVersion,
+		updateAvailable,
+		updateType: updateAvailable
+			? getUpdateType(currentVersion, latestVersion)
+			: undefined,
+	};
+
+	return cachedResult;
+}
+
+/**
+ * Format update message for display
+ */
+export function formatUpdateMessage(result: VersionCheckResult): string {
+	if (!result.updateAvailable) return "";
+
+	const typeLabel = result.updateType ? ` (${result.updateType})` : "";
+	return `Update available: v${result.currentVersion} → v${result.latestVersion}${typeLabel}. Run: npm i -g claudeup`;
+}

package/src/types/index.js

@@ -0,0 +1 @@
+export {};