@lenne.tech/cli 1.50.6 → 1.51.0

package/build/lib/plugin-utils.js

@@ -22,11 +22,11 @@ exports.setupPermissions = setupPermissions;
  * Handles reading plugin contents, permissions, and post-installation setup
  */
 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 plugin_permissions_1 = require("./plugin-permissions");
 const shell_config_1 = require("./shell-config");
 /**
  * Empty plugin contents constant (used for failed installations)
@@ -34,6 +34,7 @@ const shell_config_1 = require("./shell-config");
 exports.EMPTY_PLUGIN_CONTENTS = {
     agents: [],
     commands: [],
+    formerPermissions: [],
     hooks: 0,
     mcpServers: [],
     permissions: [],
@@ -312,10 +313,11 @@ function processPostInstall(pluginName, toolbox) {
  * @returns Plugin contents with skills, commands, agents, hooks, etc.
  */
 function readPluginContents(marketplaceName, pluginName) {
-    const pluginDir = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'plugins', 'marketplaces', marketplaceName, 'plugins', pluginName);
+    const pluginDir = (0, path_1.join)((0, claude_cli_1.getClaudeConfigDir)(), 'plugins', 'marketplaces', marketplaceName, 'plugins', pluginName);
     const result = {
         agents: [],
         commands: [],
+        formerPermissions: [],
         hooks: 0,
         mcpServers: [],
         permissions: [],
@@ -375,6 +377,9 @@ function readPluginContents(marketplaceName, pluginName) {
     if (pluginPerms === null || pluginPerms === void 0 ? void 0 : pluginPerms.permissions) {
         result.permissions = pluginPerms.permissions.map((p) => p.pattern);
     }
+    if (Array.isArray(pluginPerms === null || pluginPerms === void 0 ? void 0 : pluginPerms.formerPatterns)) {
+        result.formerPermissions = pluginPerms.formerPatterns.filter((p) => typeof p === 'string');
+    }
     return result;
 }
 /**
@@ -392,57 +397,112 @@ function safeExecCommand(command) {
     }
 }
 /**
- * Setup permissions in settings.json
- * Only adds new permissions, does not remove existing ones
- * (User may have customized permissions that should be preserved)
- * @param requiredPermissions - Array of permission patterns to add
+ * Sync a plugin's permission rules into Claude Code's user settings.json.
+ *
+ * Adds the rules the plugin ships and removes the rules lt wrote for the plugin that it no
+ * longer ships. Rules the user wrote stay untouched. How the two are told apart:
+ * plugin-permissions.ts. Rules with `${CLAUDE_PLUGIN_ROOT}` are never written.
+ * @param plugin - Marketplace and name of the plugin
+ * @param rules - `permissions` and `formerPermissions` from the plugin's permissions.json, may be empty
  * @param error - Error print function from toolbox
- * @returns Result with added and existing permissions
+ * @param options - Overrides for the Claude config directory and the ledger (tests)
+ * @returns Added, existing and removed rules
  */
-function setupPermissions(requiredPermissions, error) {
-    const settingsPath = (0, path_1.join)((0, os_1.homedir)(), '.claude', 'settings.json');
+function setupPermissions(plugin, rules, error, options = {}) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const claudeConfigDir = (_a = options.claudeConfigDir) !== null && _a !== void 0 ? _a : (0, claude_cli_1.getClaudeConfigDir)();
+    const ledgerPath = (_b = options.ledgerPath) !== null && _b !== void 0 ? _b : (0, plugin_permissions_1.getPermissionLedgerPath)();
+    const settingsPath = (0, path_1.join)(claudeConfigDir, 'settings.json');
+    const pluginKey = (0, plugin_permissions_1.pluginPermissionKey)(plugin.marketplaceName, plugin.pluginName);
+    const pluginRoot = (0, plugin_permissions_1.pluginCacheRootPattern)(claudeConfigDir, plugin.marketplaceName, plugin.pluginName);
+    const resolve = (rule) => (0, plugin_permissions_1.resolvePluginRootVariable)(rule, pluginRoot);
+    const skipped = [...new Set(rules.permissions.filter(plugin_permissions_1.hasPluginRootVariable))];
+    const written = [...new Set(rules.permissions.filter((rule) => !(0, plugin_permissions_1.hasPluginRootVariable)(rule)))];
+    const failed = {
+        added: [],
+        existing: [],
+        removed: [],
+        settingsPath,
+        skipped,
+        success: false,
+        written,
+    };
     try {
-        // Read existing settings
         let settings = {};
         if ((0, fs_1.existsSync)(settingsPath)) {
-            const content = (0, fs_1.readFileSync)(settingsPath, 'utf-8');
-            const parsed = (0, json_utils_1.safeJsonParse)(content);
-            if (parsed) {
-                settings = parsed;
+            const parsed = (0, json_utils_1.safeJsonParse)((0, fs_1.readFileSync)(settingsPath, 'utf-8'));
+            if (!isPlainObject(parsed)) {
+                // Writing now would replace every other setting in the file with an empty object.
+                error(`Could not configure permissions: ${settingsPath} is not a valid JSON object, left unchanged`);
+                return failed;
             }
+            settings = parsed;
         }
-        // Ensure permissions.allow exists
-        if (!settings.permissions) {
-            settings.permissions = {};
+        const perms = (_c = settings.permissions) !== null && _c !== void 0 ? _c : {};
+        if (!isPlainObject(perms)) {
+            error(`Could not configure permissions: "permissions" in ${settingsPath} is not an object, left unchanged`);
+            return failed;
         }
-        const perms = settings.permissions;
-        if (!perms.allow) {
-            perms.allow = [];
+        const allow = (_d = perms.allow) !== null && _d !== void 0 ? _d : [];
+        if (!Array.isArray(allow) || !allow.every((rule) => typeof rule === 'string')) {
+            error(`Could not configure permissions: "permissions.allow" in ${settingsPath} is not a list of rules, left unchanged`);
+            return failed;
         }
-        const currentAllowList = perms.allow;
-        // Determine what to add
-        const added = [];
-        const existing = [];
-        requiredPermissions.forEach((perm) => {
-            if (currentAllowList.includes(perm)) {
-                existing.push(perm);
-            }
-            else {
-                added.push(perm);
-            }
+        const ledgerEntries = (0, plugin_permissions_1.readLedgerEntries)(ledgerPath, settingsPath);
+        const entry = (_e = ledgerEntries[pluginKey]) !== null && _e !== void 0 ? _e : null;
+        const plan = (0, plugin_permissions_1.planPermissionSync)({
+            allow,
+            formerApplied: (_f = entry === null || entry === void 0 ? void 0 : entry.formerApplied) !== null && _f !== void 0 ? _f : [],
+            // A former rule with the variable may sit in settings.json in either spelling.
+            formerRules: [...new Set([...rules.formerPermissions, ...rules.formerPermissions.map(resolve)])],
+            listed: written,
+            owned: (_g = entry === null || entry === void 0 ? void 0 : entry.owned) !== null && _g !== void 0 ? _g : null,
+            ownedByOthers: Object.entries(ledgerEntries)
+                .filter(([key]) => key !== pluginKey)
+                .flatMap(([, other]) => other.owned),
+            withdrawnRules: [...skipped, ...skipped.map(resolve)],
         });
-        // Add new permissions
-        if (added.length > 0) {
-            perms.allow = [...currentAllowList, ...added];
+        if (plan.added.length > 0 || plan.removed.length > 0) {
+            perms.allow = plan.allow;
+            settings.permissions = perms;
+            (0, fs_1.mkdirSync)((0, path_1.dirname)(settingsPath), { recursive: true });
             (0, fs_1.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2));
         }
-        return { added, existing, success: true };
+        // Only after settings.json: a ledger entry must never claim a write that did not happen.
+        // If this write fails, the rules added in this run stay unrecorded, and a later run
+        // will not remove them when the plugin drops them. The message says so.
+        if (JSON.stringify(entry) !== JSON.stringify(plan.ledger)) {
+            try {
+                (0, plugin_permissions_1.recordLedgerEntry)(ledgerPath, settingsPath, pluginKey, plan.ledger);
+            }
+            catch (err) {
+                error(`Could not record lt's permission rules in ${ledgerPath}: ${err.message}. ` +
+                    'Rules added in this run will not be removed automatically when the plugin drops them.');
+            }
+        }
+        return {
+            added: plan.added,
+            existing: plan.existing,
+            removed: plan.removed,
+            settingsPath,
+            skipped,
+            success: true,
+            written,
+        };
     }
     catch (err) {
         error(`Could not configure permissions: ${err.message}`);
-        return { added: [], existing: [], success: false };
+        return failed;
     }
 }
+/**
+ * Whether a parsed JSON value is an object (not an array, not null)
+ * @param value - Parsed JSON value
+ * @returns true for a plain object
+ */
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 /**
  * Safely read and parse a JSON file
  * @param filePath - Path to the JSON file

package/build/lib/safe-paths.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileOpener = fileOpener;
+exports.isPathInside = isPathInside;
+exports.isSafePathSegment = isSafePathSegment;
+exports.openFileWithDefaultApp = openFileWithDefaultApp;
+/**
+ * Path checks for values that arrive from CLI flags or `lt.config` files. Those values can come
+ * from a repository the user cloned (a config file in a parent directory counts too) or from an
+ * AI agent running `lt` under a global permission rule, so they must not reach outside the
+ * project the command was asked to work on, and must not be handed to a shell.
+ */
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+/**
+ * The program and arguments that open a file with its default application, without a shell.
+ * Windows uses `explorer.exe`: `start` is a `cmd.exe` builtin, and `cmd.exe` re-parses its
+ * command line, where `&` in a file name (legal on Windows) would start a second command.
+ * @param platform - `process.platform`
+ * @param filePath - File to open
+ * @returns Program and argument list
+ */
+function fileOpener(platform, filePath) {
+    if (platform === 'darwin')
+        return { args: [filePath], command: 'open' };
+    if (platform === 'win32')
+        return { args: [filePath], command: 'explorer.exe' };
+    return { args: [filePath], command: 'xdg-open' };
+}
+/**
+ * Whether `target` lies inside `base` (or is `base` itself), after resolving `..` segments.
+ * @param base - Directory the target must stay in
+ * @param target - Path to check
+ * @returns true if the target does not escape the base
+ */
+function isPathInside(base, target) {
+    const rel = (0, path_1.relative)((0, path_1.resolve)(base), (0, path_1.resolve)(target));
+    return rel === '' || (!rel.startsWith('..') && !(0, path_1.isAbsolute)(rel));
+}
+/**
+ * Whether a name can be used as a single directory segment (a module or object name): no
+ * separators, not `.` or `..`, no NUL. `join(dir, name)` with anything else leaves `dir`.
+ * @param name - Name from a flag or a prompt
+ * @returns true if the name stays one segment below its parent
+ */
+function isSafePathSegment(name) {
+    return Boolean(name) && name !== '.' && name !== '..' && !/[/\\\0]/.test(name);
+}
+/**
+ * Open a file with its default application. Fire and forget, like before; `explorer.exe` exits
+ * with 1 even on success, so errors are ignored.
+ * @param filePath - File to open
+ */
+function openFileWithDefaultApp(filePath) {
+    const { args, command } = fileOpener(process.platform, filePath);
+    (0, child_process_1.execFile)(command, args, () => undefined);
+}

package/build/lib/unknown-options.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Flags a command did not declare.
+ *
+ * gluegun parses argv with yargs-parser and no schema, so a misspelt flag is silently ignored.
+ * For `lt fullstack convert-mode` that converted more than asked: the plugin docs said
+ * `--skip-app`, the CLI only knows `--skip-frontend`, and with `--noConfirm` the frontend was
+ * converted although the caller had asked to skip it. A command that changes a project should
+ * refuse a flag it does not know rather than guess.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findUnknownOptions = findUnknownOptions;
+exports.formatUnknownOptions = formatUnknownOptions;
+/** Flags every command accepts: gluegun's menu, `bin/lt`, the help interceptor, confirmations. */
+const GLOBAL_OPTIONS = ['compiled-build', 'fromGluegunMenu', 'h', 'help', 'help-json', 'noConfirm'];
+/**
+ * Options in `options` that are neither declared nor global. yargs-parser reports a kebab-case
+ * flag twice (`skip-app` and `skipApp`); it is reported once, in the spelling that was typed.
+ * @param options - `parameters.options` of the command
+ * @param declaredFlags - The command's flags, with or without leading dashes (e.g. from its `help`)
+ * @returns Unknown option names, without dashes
+ */
+function findUnknownOptions(options, declaredFlags) {
+    const accepted = new Set([...declaredFlags.map((flag) => flag.replace(/^-+/, '')), ...GLOBAL_OPTIONS].map(toCamel));
+    const unknown = new Map();
+    for (const key of Object.keys(options)) {
+        const camel = toCamel(key);
+        if (!accepted.has(camel) && !unknown.has(camel)) {
+            unknown.set(camel, key);
+        }
+    }
+    return [...unknown.values()];
+}
+/**
+ * Error text for unknown options, with the right name where a known misspelling has one.
+ * @param unknown - Result of {@link findUnknownOptions}
+ * @param declaredFlags - The command's flags
+ * @param renamed - Known wrong name → right flag, without dashes (e.g. `skip-app` → `skip-frontend`)
+ * @returns Message naming each unknown flag and listing the known ones
+ */
+function formatUnknownOptions(unknown, declaredFlags, renamed = {}) {
+    const listed = unknown.map((name) => (renamed[name] ? `--${name} (use --${renamed[name]})` : `--${name}`));
+    const known = declaredFlags.map((flag) => `--${flag.replace(/^-+/, '')}`).join(', ');
+    return `Unknown option${unknown.length > 1 ? 's' : ''}: ${listed.join(', ')}. Nothing was changed.\nKnown options: ${known}`;
+}
+/**
+ * `skip-app` → `skipApp`, as yargs-parser expands it
+ * @param name - Option name
+ * @returns camelCase form
+ */
+function toCamel(name) {
+    return name.replace(/-([a-z0-9])/g, (_, char) => char.toUpperCase());
+}

package/build/lib/workspace-integration.js

@@ -83,6 +83,7 @@ exports.writeApiConfig = writeApiConfig;
 const yaml = __importStar(require("js-yaml"));
 const path_1 = require("path");
 const ensure_root_dockerignore_1 = require("./ensure-root-dockerignore");
+const exec_args_1 = require("./exec-args");
 const hoist_workspace_pnpm_config_1 = require("./hoist-workspace-pnpm-config");
 const remove_nested_lockfiles_1 = require("./remove-nested-lockfiles");
 /**
@@ -321,7 +322,7 @@ function reportWorkspaceConflicts(conflicts, warn) {
  */
 function runExperimentalNestBaseRename(options) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { apiDir, patching, projectDir, system } = options;
+        const { apiDir, patching, projectDir, run = exec_args_1.spawnArgs } = options;
         // setupServerForFullstack already patched package.json to set
         // `name = projectDir`. The rename planner reads that name as the
         // "old" slug, which would short-circuit the rest of the rewrites
@@ -333,7 +334,8 @@ function runExperimentalNestBaseRename(options) {
             return config;
         });
         try {
-            yield system.run(`cd ${apiDir} && bun run rename ${projectDir}`);
+            // No shell: projectDir can come from --name or the directory name (see exec-args.ts).
+            yield run('bun', ['run', 'rename', projectDir], { cwd: apiDir });
             return { attempted: true };
         }
         catch (err) {

package/docs/commands.md

@@ -426,6 +426,8 @@ lt dev init --skip-install   # do NOT auto-run `lt dev install` first
 
 Start API + App behind Caddy. Allocates internal ports (4000+), spawns processes detached, persists PIDs to `<root>/.lt-dev/state.json`.
 
+Caddy listens on the loopback interfaces only (`default_bind 127.0.0.1 [::1]` in the global options block of `~/.lenneTech/Caddyfile`), so a running stack is not reachable from the local network. `lt dev up` adds the block to a Caddyfile written by an older CLI and reloads Caddy. A `default_bind` you set yourself is left as it is.
+
 **Usage:**
 ```bash
 lt dev up
@@ -1283,6 +1285,8 @@ lt fullstack convert-mode --to <vendor|npm> [options]
 | `--dry-run` | Show the resolved plan without making any changes |
 | `--noConfirm` | Skip confirmation prompt |
 
+Any other flag is refused with exit code 1 before anything is converted, and a known wrong name gets the right one in the message (`--skip-app` → `--skip-frontend`, `--api-version` → `--framework-version`, …). Before, an unknown flag was ignored, so a misspelt `--skip-*` together with `--noConfirm` converted the side it was meant to skip. `lt server convert-mode` and `lt frontend convert-mode` refuse unknown flags the same way.
+
 **Subproject Detection:**
 
 The command searches for subprojects in this order:
@@ -1994,6 +1998,14 @@ To list or uninstall installed plugins, use Claude Code's own `/plugin` menu.
 **Default Behavior:**
 When run without a plugin name, all lenne.Tech plugins plus recommended external plugins (like `typescript-lsp`) are installed automatically. Plugins from configured `autoInstall` marketplaces are added as well, but only for users who can access the underlying repository — everyone else silently skips them.
 
+**Permission rules:**
+A plugin's `permissions.json` is synced into Claude Code's user `settings.json` (`$CLAUDE_CONFIG_DIR/settings.json`, default `~/.claude/settings.json`). These rules apply in every project, so the sync goes both ways:
+
+- Rules the plugin ships are added, except rules that use `${CLAUDE_PLUGIN_ROOT}`. Claude Code does not expand that variable in permission rules, so such a rule never matches, and replacing it with the plugin's cache directory plus a wildcard for the version folder would allow any file on disk (a wildcard also matches `../`). lt therefore writes neither form and removes both if present; Claude asks before running those plugin scripts.
+- Rules lt wrote for a plugin that the plugin no longer ships are removed, and listed as `removed:` in the output. lt records the rules it wrote in `~/.lenneTech/claude-plugin-permissions.json`. Rules you added yourself are never removed.
+- Rules older lt versions installed before that record existed are named by the plugin itself, in an optional `formerPatterns` list of strings in its `permissions.json` (e.g. `"formerPatterns": ["Bash(curl:*)", "Bash(rm:*)"]`). lt removes each of them once, unless the plugin still ships it. Add one back by hand if you want it; lt leaves it alone after that.
+- If `settings.json` is not valid JSON, lt leaves it unchanged and reports an error.
+
 **Examples:**
 ```bash
 # Install all recommended plugins (lenne.Tech + recommended external)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/cli",
-  "version": "1.50.6",
+  "version": "1.51.0",
   "description": "lenne.Tech CLI: lt",
   "keywords": [
     "lenne.Tech",
@@ -58,13 +58,13 @@
     "bin"
   ],
   "dependencies": {
-    "@aws-sdk/client-s3": "3.1149.0",
+    "@aws-sdk/client-s3": "3.1152.0",
     "@lenne.tech/cli-plugin-helper": "0.0.14",
     "axios": "1.20.0",
     "bcrypt": "6.0.0",
     "cross-spawn": "7.0.6",
     "defuddle": "0.19.5",
-    "ejs": "7.0.1",
+    "ejs": "7.0.2",
     "glob": "13.0.6",
     "gluegun": "5.2.2",
     "js-sha256": "1.0.0",
@@ -73,7 +73,7 @@
     "jsonc-parser": "3.3.1",
     "lodash": "4.18.1",
     "open": "11.0.4",
-    "playwright-core": "1.64.0",
+    "playwright-core": "1.64.1",
     "ts-morph": "28.0.0",
     "ts-node": "10.9.2",
     "turndown": "7.2.4",
@@ -97,13 +97,13 @@
     "@types/lodash": "4.17.26",
     "@types/node": "26.6.5",
     "@types/turndown": "5.0.6",
-    "eslint": "10.12.0",
+    "eslint": "10.13.0",
     "husky": "9.1.7",
     "jest": "30.5.2",
     "minimatch": "10.2.6",
     "prettier": "3.9.10",
     "rimraf": "6.1.3",
-    "ts-jest": "29.4.14"
+    "ts-jest": "29.4.15"
   },
   "//overrides": {
     "semver@*": "Force latest semver 7.x across all sub-deps; gluegun@5.2.2 pins semver@7.7.0 which is stale - remove once gluegun updates its dep.",