@lenne.tech/cli 1.45.0 → 1.47.0

package/build/lib/platform.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findExecutable = findExecutable;
+exports.isWindows = isWindows;
+exports.spawnCmdSync = spawnCmdSync;
+exports.windowsAppData = windowsAppData;
+const cross_spawn_1 = require("cross-spawn");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const DEFAULT_PATHEXT = '.COM;.EXE;.BAT;.CMD';
+/**
+ * Resolve a binary the way a shell would, without spawning `which`/`where.exe`.
+ *
+ * `candidates` win over PATH, in order. On Windows each PATH directory is
+ * probed with every PATHEXT extension; an extensionless file is never matched
+ * there, because Node cannot spawn it (it is typically a Git Bash script).
+ *
+ * @returns Absolute path of the first match, or null
+ */
+function findExecutable(name, options = {}) {
+    const { candidates = [], env = process.env, isExecutableFile = isExecutableFileOnDisk } = options;
+    const windows = isWindows(options.platform);
+    const pathApi = windows ? path_1.win32 : path_1.posix;
+    for (const candidate of candidates) {
+        if (isExecutableFile(candidate)) {
+            return candidate;
+        }
+    }
+    const dirs = (readEnv(env, 'PATH', windows) || '')
+        .split(pathApi.delimiter)
+        .map((dir) => dir.trim().replace(/^"(.*)"$/, '$1'))
+        .filter(Boolean);
+    const names = windows ? windowsNameVariants(name, readEnv(env, 'PATHEXT', windows)) : [name];
+    for (const dir of dirs) {
+        for (const variant of names) {
+            const full = pathApi.join(dir, variant);
+            if (isExecutableFile(full)) {
+                return full;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * True for native Windows (PowerShell, cmd.exe and Git Bash alike — Node
+ * reports `win32` in all three).
+ */
+function isWindows(platform = process.platform) {
+    return platform === 'win32';
+}
+/**
+ * `spawnSync` that also runs `.cmd`/`.bat` shims on Windows.
+ *
+ * Delegates to cross-spawn, which is a plain `child_process.spawnSync` on
+ * macOS/Linux. On Windows it resolves the shim and runs it through cmd.exe with
+ * escaped arguments.
+ *
+ * Limit on Windows: cross-spawn escapes cmd.exe metacharacters (`& | % ^ …`) twice
+ * only for shims under `node_modules\.bin`. A global npm shim such as
+ * `%APPDATA%\npm\claude.cmd` re-parses its `%*`, so there a metacharacter can
+ * still take effect. Pass plain arguments (names, slugs, paths), never
+ * untrusted free text.
+ */
+function spawnCmdSync(command, args = [], options = {}) {
+    return (0, cross_spawn_1.sync)(command, [...args], Object.assign({ encoding: 'utf-8' }, options));
+}
+/**
+ * `%APPDATA%` (roaming profile), home of npm's global `.cmd` shims on Windows.
+ */
+function windowsAppData(env, home) {
+    return readEnv(env, 'APPDATA', true) || path_1.win32.join(home, 'AppData', 'Roaming');
+}
+function isExecutableFileOnDisk(path) {
+    try {
+        if (!(0, fs_1.statSync)(path).isFile()) {
+            return false;
+        }
+        // Windows has no execute bit; X_OK degrades to an existence check there
+        (0, fs_1.accessSync)(path, fs_1.constants.X_OK);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Windows environment keys are case-insensitive (`Path` is the usual spelling).
+ * `process.env` hides that, a plain object passed in a test does not.
+ */
+function readEnv(env, key, windows) {
+    if (!windows) {
+        return env[key];
+    }
+    const match = Object.keys(env).find((k) => k.toUpperCase() === key);
+    return match ? env[match] : undefined;
+}
+function windowsNameVariants(name, pathExt) {
+    const extensions = (pathExt || DEFAULT_PATHEXT)
+        .split(';')
+        .map((ext) => ext.trim().toLowerCase())
+        .filter(Boolean);
+    const ownExtension = path_1.win32.extname(name).toLowerCase();
+    if (ownExtension && extensions.includes(ownExtension)) {
+        return [name];
+    }
+    return extensions.map((ext) => `${name}${ext}`);
+}

package/build/lib/plugin-utils.js

@@ -21,12 +21,12 @@ exports.setupPermissions = setupPermissions;
  * Plugin utilities for Claude Code plugin management
  * Handles reading plugin contents, permissions, and post-installation setup
  */
-const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
 const claude_cli_1 = require("./claude-cli");
 const json_utils_1 = require("./json-utils");
+const platform_1 = require("./platform");
 const shell_config_1 = require("./shell-config");
 /**
  * Empty plugin contents constant (used for failed installations)
@@ -62,8 +62,8 @@ exports.PLUGIN_POST_INSTALL = {
         ],
         requirements: [
             {
-                checkCommand: 'which typescript-language-server',
                 description: 'TypeScript language server',
+                executable: 'typescript-language-server',
                 installCommand: 'npm install -g typescript-language-server typescript',
             },
         ],
@@ -245,10 +245,11 @@ function processPostInstall(pluginName, toolbox) {
     // Check and install requirements
     if (postInstall.requirements) {
         for (const req of postInstall.requirements) {
-            // If checkCommand is provided, verify if requirement is already met
-            if (req.checkCommand) {
+            // If executable or checkCommand is provided, verify if requirement is already met
+            if (req.executable || req.checkCommand) {
+                const isMet = () => req.executable ? (0, platform_1.findExecutable)(req.executable) !== null : (0, claude_cli_1.checkCommandExists)(req.checkCommand);
                 const checkSpinner = spin(`Checking ${req.description}`);
-                if ((0, claude_cli_1.checkCommandExists)(req.checkCommand)) {
+                if (isMet()) {
                     checkSpinner.succeed(`${req.description} already installed`);
                     continue;
                 }
@@ -257,7 +258,7 @@ function processPostInstall(pluginName, toolbox) {
                 try {
                     safeExecCommand(req.installCommand);
                     // Verify installation
-                    if ((0, claude_cli_1.checkCommandExists)(req.checkCommand)) {
+                    if (isMet()) {
                         checkSpinner.succeed(`${req.description} installed`);
                         result.requirementsInstalled.push(req.description);
                     }
@@ -377,7 +378,7 @@ function readPluginContents(marketplaceName, pluginName) {
     return result;
 }
 /**
- * Execute a shell command safely using spawnSync (no shell interpretation)
+ * Execute a shell command safely using spawnCmdSync (no shell interpretation, `.cmd` shims such as npm work on Windows)
  * Splits the command string into executable and arguments to prevent command injection
  * @param command - Command string to execute (e.g., 'npm install -g typescript')
  * @throws Error if command fails (non-zero exit code or signal)
@@ -385,7 +386,7 @@ function readPluginContents(marketplaceName, pluginName) {
 function safeExecCommand(command) {
     var _a;
     const [cmd, ...args] = command.trim().split(/\s+/);
-    const result = (0, child_process_1.spawnSync)(cmd, args, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+    const result = (0, platform_1.spawnCmdSync)(cmd, args, { stdio: ['pipe', 'pipe', 'pipe'] });
     if (result.status !== 0 || result.error) {
         throw new Error(result.stderr || ((_a = result.error) === null || _a === void 0 ? void 0 : _a.message) || `Command failed: ${command}`);
     }