@lenne.tech/cli 1.6.2 → 1.6.4

package/build/lib/claude-cli.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_MARKETPLACES_DIR = void 0;
+exports.checkCommandExists = checkCommandExists;
+exports.checkMarketplaceExists = checkMarketplaceExists;
+exports.findClaudeCli = findClaudeCli;
+exports.runClaudeCommand = runClaudeCommand;
+/**
+ * Claude CLI utilities
+ * Handles detection and execution of Claude CLI commands
+ */
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+/**
+ * Path to Claude plugins marketplaces directory
+ */
+exports.CLAUDE_MARKETPLACES_DIR = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'plugins', 'marketplaces');
+/**
+ * Check if a shell command exists and succeeds
+ * @param command - Command to check (e.g., 'which typescript-language-server')
+ * @returns true if command exits with code 0
+ */
+function checkCommandExists(command) {
+    try {
+        (0, child_process_1.execSync)(command, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Check if a marketplace is already installed
+ * @param marketplaceName - Name of the marketplace to check
+ * @returns true if marketplace directory exists
+ */
+function checkMarketplaceExists(marketplaceName) {
+    return (0, fs_1.existsSync)((0, path_1.join)(exports.CLAUDE_MARKETPLACES_DIR, marketplaceName));
+}
+/**
+ * Find the Claude CLI executable path
+ * Checks common installation locations and falls back to 'which'
+ * @returns Path to Claude CLI or null if not found
+ */
+function findClaudeCli() {
+    const possiblePaths = [
+        (0, path_1.join)((0, os_1.homedir)(), '.claude', 'local', 'claude'),
+        '/usr/local/bin/claude',
+        '/usr/bin/claude',
+    ];
+    for (const p of possiblePaths) {
+        if ((0, fs_1.existsSync)(p)) {
+            return p;
+        }
+    }
+    try {
+        const result = (0, child_process_1.execSync)('which claude', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+        const path = result.trim();
+        if (path && (0, fs_1.existsSync)(path)) {
+            return path;
+        }
+    }
+    catch (_a) {
+        // Claude CLI not found in PATH
+    }
+    return null;
+}
+/**
+ * Execute a Claude CLI command
+ * @param cli - Path to Claude CLI executable
+ * @param args - Command arguments as string (e.g., 'plugin install foo')
+ * @returns Command result with output and success status
+ */
+function runClaudeCommand(cli, args) {
+    try {
+        const result = (0, child_process_1.spawnSync)(cli, args.split(' '), {
+            encoding: 'utf-8',
+            shell: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return {
+            output: result.stdout + result.stderr,
+            success: result.status === 0,
+        };
+    }
+    catch (err) {
+        return {
+            output: err.message,
+            success: false,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhdWRlLWNsaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9saWIvY2xhdWRlLWNsaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUE2QkEsZ0RBT0M7QUFPRCx3REFFQztBQU9ELHNDQXdCQztBQVFELDRDQWlCQztBQXJHRDs7O0dBR0c7QUFDSCxpREFBb0Q7QUFDcEQsMkJBQWdDO0FBQ2hDLDJCQUE2QjtBQUM3QiwrQkFBNEI7QUFFNUI7O0dBRUc7QUFDVSxRQUFBLHVCQUF1QixHQUFHLElBQUEsV0FBSSxFQUFDLElBQUEsWUFBTyxHQUFFLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxjQUFjLENBQUMsQ0FBQztBQVk3Rjs7OztHQUlHO0FBQ0gsU0FBZ0Isa0JBQWtCLENBQUMsT0FBZTtJQUNoRCxJQUFJLENBQUM7UUFDSCxJQUFBLHdCQUFRLEVBQUMsT0FBTyxFQUFFLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRSxLQUFLLEVBQUUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUMxRSxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7SUFBQyxXQUFNLENBQUM7UUFDUCxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7QUFDSCxDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILFNBQWdCLHNCQUFzQixDQUFDLGVBQXVCO0lBQzVELE9BQU8sSUFBQSxlQUFVLEVBQUMsSUFBQSxXQUFJLEVBQUMsK0JBQXVCLEVBQUUsZUFBZSxDQUFDLENBQUMsQ0FBQztBQUNwRSxDQUFDO0FBRUQ7Ozs7R0FJRztBQUNILFNBQWdCLGFBQWE7SUFDM0IsTUFBTSxhQUFhLEdBQUc7UUFDcEIsSUFBQSxXQUFJLEVBQUMsSUFBQSxZQUFPLEdBQUUsRUFBRSxTQUFTLEVBQUUsT0FBTyxFQUFFLFFBQVEsQ0FBQztRQUM3Qyx1QkFBdUI7UUFDdkIsaUJBQWlCO0tBQ2xCLENBQUM7SUFFRixLQUFLLE1BQU0sQ0FBQyxJQUFJLGFBQWEsRUFBRSxDQUFDO1FBQzlCLElBQUksSUFBQSxlQUFVLEVBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztZQUNsQixPQUFPLENBQUMsQ0FBQztRQUNYLENBQUM7SUFDSCxDQUFDO0lBRUQsSUFBSSxDQUFDO1FBQ0gsTUFBTSxNQUFNLEdBQUcsSUFBQSx3QkFBUSxFQUFDLGNBQWMsRUFBRSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLENBQUMsTUFBTSxFQUFFLE1BQU0sRUFBRSxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDaEcsTUFBTSxJQUFJLEdBQUcsTUFBTSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQzNCLElBQUksSUFBSSxJQUFJLElBQUEsZUFBVSxFQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7WUFDN0IsT0FBTyxJQUFJLENBQUM7UUFDZCxDQUFDO0lBQ0gsQ0FBQztJQUFDLFdBQU0sQ0FBQztRQUNQLCtCQUErQjtJQUNqQyxDQUFDO0lBRUQsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBRUQ7Ozs7O0dBS0c7QUFDSCxTQUFnQixnQkFBZ0IsQ0FBQyxHQUFXLEVBQUUsSUFBWTtJQUN4RCxJQUFJLENBQUM7UUFDSCxNQUFNLE1BQU0sR0FBRyxJQUFBLHlCQUFTLEVBQUMsR0FBRyxFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDN0MsUUFBUSxFQUFFLE9BQU87WUFDakIsS0FBSyxFQUFFLElBQUk7WUFDWCxLQUFLLEVBQUUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxFQUFFLE1BQU0sQ0FBQztTQUNoQyxDQUFDLENBQUM7UUFDSCxPQUFPO1lBQ0wsTUFBTSxFQUFFLE1BQU0sQ0FBQyxNQUFNLEdBQUcsTUFBTSxDQUFDLE1BQU07WUFDckMsT0FBTyxFQUFFLE1BQU0sQ0FBQyxNQUFNLEtBQUssQ0FBQztTQUM3QixDQUFDO0lBQ0osQ0FBQztJQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7UUFDYixPQUFPO1lBQ0wsTUFBTSxFQUFHLEdBQWEsQ0FBQyxPQUFPO1lBQzlCLE9BQU8sRUFBRSxLQUFLO1NBQ2YsQ0FBQztJQUNKLENBQUM7QUFDSCxDQUFDIn0=

package/build/lib/json-utils.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * JSON utility functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeJsonParse = safeJsonParse;
+/**
+ * Safely parse JSON without throwing
+ * @param text - JSON string to parse
+ * @returns Parsed object or null if parsing fails
+ */
+function safeJsonParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (_a) {
+        return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNvbi11dGlscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9saWIvanNvbi11dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7O0dBRUc7O0FBT0gsc0NBTUM7QUFYRDs7OztHQUlHO0FBQ0gsU0FBZ0IsYUFBYSxDQUFJLElBQVk7SUFDM0MsSUFBSSxDQUFDO1FBQ0gsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBTSxDQUFDO0lBQy9CLENBQUM7SUFBQyxXQUFNLENBQUM7UUFDUCxPQUFPLElBQUksQ0FBQztJQUNkLENBQUM7QUFDSCxDQUFDIn0=

package/build/lib/marketplace.js

@@ -0,0 +1,160 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_EXTERNAL_PLUGINS = exports.MARKETPLACES = void 0;
+exports.fetchAvailablePlugins = fetchAvailablePlugins;
+exports.fetchPluginsFromMarketplace = fetchPluginsFromMarketplace;
+exports.printAvailablePlugins = printAvailablePlugins;
+/**
+ * Plugin marketplace utilities
+ * Handles fetching and managing plugins from GitHub-based marketplaces
+ */
+const json_utils_1 = require("./json-utils");
+/**
+ * Available marketplaces for plugin discovery
+ */
+exports.MARKETPLACES = [
+    {
+        apiBase: 'https://api.github.com/repos/lenneTech/claude-code/contents',
+        name: 'lenne-tech',
+        rawBase: 'https://raw.githubusercontent.com/lenneTech/claude-code/main',
+        repo: 'lenneTech/claude-code',
+    },
+    {
+        apiBase: 'https://api.github.com/repos/anthropics/claude-plugins-official/contents',
+        name: 'claude-plugins-official',
+        rawBase: 'https://raw.githubusercontent.com/anthropics/claude-plugins-official/main',
+        repo: 'anthropics/claude-plugins-official',
+    },
+];
+/**
+ * Default plugins to install when no specific plugins are requested
+ * These are installed in addition to all plugins from the primary marketplace (lenne-tech)
+ */
+exports.DEFAULT_EXTERNAL_PLUGINS = [
+    { marketplaceName: 'claude-plugins-official', pluginName: 'typescript-lsp' },
+];
+/**
+ * Fetch available plugins from all configured marketplaces
+ * @param spin - Spinner factory function from toolbox
+ * @returns Array of plugin configurations
+ * @throws Error if no plugins are found
+ */
+function fetchAvailablePlugins(spin) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const spinner = spin('Fetching available plugins from marketplaces');
+        try {
+            // Fetch plugins from all marketplaces in parallel
+            const results = yield Promise.all(exports.MARKETPLACES.map(marketplace => fetchPluginsFromMarketplace(marketplace)));
+            // Flatten results
+            const plugins = results.flat();
+            if (plugins.length === 0) {
+                spinner.fail('No plugins found in any marketplace');
+                throw new Error('No plugins found');
+            }
+            // Group by marketplace for display
+            const byMarketplace = exports.MARKETPLACES.map(m => ({
+                count: plugins.filter(p => p.marketplaceName === m.name).length,
+                name: m.name,
+            })).filter(m => m.count > 0);
+            const summary = byMarketplace.map(m => `${m.name}: ${m.count}`).join(', ');
+            spinner.succeed(`Found ${plugins.length} plugins (${summary})`);
+            return plugins;
+        }
+        catch (err) {
+            spinner.fail('Failed to fetch plugins from marketplaces');
+            throw err;
+        }
+    });
+}
+/**
+ * Fetch available plugins from a single marketplace
+ * First tries central marketplace.json, then falls back to directory scan
+ * @param marketplace - Marketplace configuration
+ * @returns Array of plugin configurations
+ */
+function fetchPluginsFromMarketplace(marketplace) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const plugins = [];
+        try {
+            // First try to read central marketplace.json (used by official marketplace)
+            const marketplaceJsonUrl = `${marketplace.rawBase}/.claude-plugin/marketplace.json`;
+            const marketplaceJsonResponse = yield fetch(marketplaceJsonUrl);
+            if (marketplaceJsonResponse.ok) {
+                const text = yield marketplaceJsonResponse.text();
+                const marketplaceManifest = (0, json_utils_1.safeJsonParse)(text);
+                if ((marketplaceManifest === null || marketplaceManifest === void 0 ? void 0 : marketplaceManifest.plugins) && marketplaceManifest.plugins.length > 0) {
+                    for (const plugin of marketplaceManifest.plugins) {
+                        plugins.push({
+                            description: plugin.description || '',
+                            marketplaceName: marketplace.name,
+                            marketplaceRepo: marketplace.repo,
+                            pluginName: plugin.name,
+                        });
+                    }
+                    return plugins;
+                }
+            }
+            // Fallback: Get list of plugin directories and read individual plugin.json files
+            const dirResponse = yield fetch(`${marketplace.apiBase}/plugins`);
+            if (!dirResponse.ok) {
+                return plugins;
+            }
+            const text = yield dirResponse.text();
+            const directories = (0, json_utils_1.safeJsonParse)(text);
+            if (!directories) {
+                return plugins;
+            }
+            const pluginDirs = directories.filter(d => d.type === 'dir');
+            // Fetch plugin.json for each plugin in parallel
+            const manifestPromises = pluginDirs.map((dir) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    const manifestUrl = `${marketplace.rawBase}/plugins/${dir.name}/.claude-plugin/plugin.json`;
+                    const manifestResponse = yield fetch(manifestUrl);
+                    if (manifestResponse.ok) {
+                        const manifestText = yield manifestResponse.text();
+                        const manifest = (0, json_utils_1.safeJsonParse)(manifestText);
+                        if (manifest) {
+                            return {
+                                description: manifest.description,
+                                marketplaceName: marketplace.name,
+                                marketplaceRepo: marketplace.repo,
+                                pluginName: manifest.name,
+                            };
+                        }
+                    }
+                }
+                catch (_a) {
+                    // Skip plugins without valid manifest
+                }
+                return null;
+            }));
+            const results = yield Promise.all(manifestPromises);
+            plugins.push(...results.filter((p) => p !== null));
+        }
+        catch (_a) {
+            // Marketplace fetch failed, return empty array
+        }
+        return plugins;
+    });
+}
+/**
+ * Print available plugins list
+ * @param plugins - Array of plugin configurations
+ * @param info - Info print function from toolbox
+ */
+function printAvailablePlugins(plugins, info) {
+    info('Available plugins:');
+    for (const plugin of plugins) {
+        info(`  ${plugin.pluginName} - ${plugin.description}`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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