@oh-my-pi/cli 0.1.0 → 0.3.0

package/src/commands/install.ts

@@ -1,24 +1,204 @@
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { cp, mkdir, readFile, rm } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
-import chalk from "chalk";
-import { type Conflict, detectConflicts, formatConflicts } from "../conflicts.js";
+import { type Conflict, detectConflicts, detectIntraPluginDuplicates, formatConflicts } from "@omp/conflicts";
+import { updateLockFile } from "@omp/lockfile";
 import {
 	getInstalledPlugins,
 	initGlobalPlugins,
+	initProjectPlugins,
 	loadPluginsJson,
+	type PluginConfig,
 	type PluginPackageJson,
+	type PluginsJson,
 	readPluginPackageJson,
 	savePluginsJson,
-} from "../manifest.js";
-import { npmInfo, npmInstall } from "../npm.js";
-import { NODE_MODULES_DIR, PLUGINS_DIR, PROJECT_NODE_MODULES, PROJECT_PLUGINS_JSON } from "../paths.js";
-import { createPluginSymlinks } from "../symlinks.js";
+} from "@omp/manifest";
+import { npmInfo, npmInstall } from "@omp/npm";
+import {
+	NODE_MODULES_DIR,
+	PI_CONFIG_DIR,
+	PLUGINS_DIR,
+	PROJECT_NODE_MODULES,
+	PROJECT_PI_DIR,
+	resolveScope,
+} from "@omp/paths";
+import { createPluginSymlinks, getAllFeatureNames, getDefaultFeatures } from "@omp/symlinks";
+import chalk from "chalk";
+
+/**
+ * Parsed package specifier with optional features
+ */
+export interface ParsedPackageSpec {
+	name: string;
+	version: string;
+	/** null = not specified, [] = explicit empty, string[] = specific features */
+	features: string[] | null;
+	/** true if [*] was used */
+	allFeatures: boolean;
+}
+
+/**
+ * Parse package specifier with optional features bracket syntax.
+ * Examples:
+ *   "exa" -> { name: "exa", version: "latest", features: null }
+ *   "exa@^1.0" -> { name: "exa", version: "^1.0", features: null }
+ *   "exa[search]" -> { name: "exa", version: "latest", features: ["search"] }
+ *   "exa[search,websets]@^1.0" -> { name: "exa", version: "^1.0", features: ["search", "websets"] }
+ *   "@scope/exa[*]" -> { name: "@scope/exa", version: "latest", allFeatures: true }
+ *   "exa[]" -> { name: "exa", version: "latest", features: [] } (no optional features)
+ */
+export function parsePackageSpecWithFeatures(spec: string): ParsedPackageSpec {
+	// Regex breakdown:
+	// ^(@?[^@[\]]+)  - Capture name (optionally scoped with @, no @ [ or ] in name)
+	// (?:\[([^\]]*)\])?  - Optionally capture features inside []
+	// (?:@(.+))?$  - Optionally capture version after @
+	const match = spec.match(/^(@?[^@[\]]+)(?:\[([^\]]*)\])?(?:@(.+))?$/);
+
+	if (!match) {
+		// Fallback: treat as plain name
+		return { name: spec, version: "latest", features: null, allFeatures: false };
+	}
+
+	const [, name, featuresStr, version = "latest"] = match;
+
+	// No bracket at all
+	if (featuresStr === undefined) {
+		return { name, version, features: null, allFeatures: false };
+	}
+
+	// [*] = all features
+	if (featuresStr === "*") {
+		return { name, version, features: null, allFeatures: true };
+	}
+
+	// [] = explicit empty (no optional features, core only)
+	if (featuresStr === "") {
+		return { name, version, features: [], allFeatures: false };
+	}
+
+	// [f1,f2,...] = specific features
+	const features = featuresStr.split(",").map((f) => f.trim()).filter(Boolean);
+	return { name, version, features, allFeatures: false };
+}
+
+/**
+ * Resolve which features to enable based on user request, existing config, and plugin defaults.
+ *
+ * Resolution order:
+ * 1. User explicitly requested [*] -> all features
+ * 2. User explicitly specified [f1,f2] -> exactly those features
+ * 3. Reinstall with no bracket -> preserve existing selection
+ * 4. First install with no bracket -> ALL features
+ */
+export function resolveFeatures(
+	pkgJson: PluginPackageJson,
+	requested: ParsedPackageSpec,
+	existingConfig: PluginConfig | undefined,
+	isReinstall: boolean,
+): { enabledFeatures: string[]; configToStore: PluginConfig | undefined } {
+	const pluginFeatures = pkgJson.omp?.features || {};
+	const allFeatureNames = Object.keys(pluginFeatures);
+
+	// No features defined in plugin -> nothing to configure
+	if (allFeatureNames.length === 0) {
+		return { enabledFeatures: [], configToStore: undefined };
+	}
+
+	// Case 1: User explicitly requested [*] -> all features
+	if (requested.allFeatures) {
+		return {
+			enabledFeatures: allFeatureNames,
+			configToStore: { features: ["*"] },
+		};
+	}
+
+	// Case 2: User explicitly specified features -> use exactly those
+	if (requested.features !== null) {
+		// Validate requested features exist
+		for (const f of requested.features) {
+			if (!pluginFeatures[f]) {
+				throw new Error(`Unknown feature "${f}". Available: ${allFeatureNames.join(", ")}`);
+			}
+		}
+		return {
+			enabledFeatures: requested.features,
+			configToStore: { features: requested.features },
+		};
+	}
+
+	// Case 3: Reinstall with no bracket -> preserve existing config
+	if (isReinstall && existingConfig?.features !== undefined) {
+		const storedFeatures = existingConfig.features;
+
+		// null means "first install, used defaults" - recompute defaults in case plugin updated
+		if (storedFeatures === null) {
+			return {
+				enabledFeatures: getDefaultFeatures(pluginFeatures),
+				configToStore: undefined, // Keep existing
+			};
+		}
+
+		// ["*"] means explicitly all
+		if (Array.isArray(storedFeatures) && storedFeatures.includes("*")) {
+			return {
+				enabledFeatures: allFeatureNames,
+				configToStore: undefined,
+			};
+		}
+
+		// Specific features
+		return {
+			enabledFeatures: storedFeatures as string[],
+			configToStore: undefined,
+		};
+	}
+
+	// Case 4: First install with no bracket -> use DEFAULT features
+	if (!isReinstall) {
+		const defaultFeatures = getDefaultFeatures(pluginFeatures);
+		return {
+			enabledFeatures: defaultFeatures,
+			configToStore: { features: null }, // null = "first install, used defaults"
+		};
+	}
+
+	// Case 5: Reinstall, no existing config -> use defaults
+	return {
+		enabledFeatures: getDefaultFeatures(pluginFeatures),
+		configToStore: undefined,
+	};
+}
+
+/**
+ * Process omp dependencies recursively with cycle detection.
+ * Creates symlinks for dependencies that have omp.install entries.
+ */
+async function processOmpDependencies(pkgJson: PluginPackageJson, isGlobal: boolean, seen: Set<string>): Promise<void> {
+	if (!pkgJson.dependencies) return;
+
+	for (const depName of Object.keys(pkgJson.dependencies)) {
+		if (seen.has(depName)) {
+			console.log(chalk.yellow(`  Skipping circular dependency: ${depName}`));
+			continue;
+		}
+		seen.add(depName);
+
+		const depPkgJson = await readPluginPackageJson(depName, isGlobal);
+		if (depPkgJson?.omp?.install) {
+			console.log(chalk.dim(`  Processing dependency: ${depName}`));
+			await createPluginSymlinks(depName, depPkgJson, isGlobal);
+			// Recurse into this dependency's dependencies
+			await processOmpDependencies(depPkgJson, isGlobal, seen);
+		}
+	}
+}
 
 export interface InstallOptions {
 	global?: boolean;
+	local?: boolean;
 	save?: boolean;
 	saveDev?: boolean;
 	force?: boolean;
@@ -53,34 +233,6 @@ async function promptConflictResolution(conflict: Conflict): Promise<number | nu
 	});
 }
 
-/**
- * Parse package specifier into name and version
- */
-function parsePackageSpec(spec: string): { name: string; version: string } {
-	// Handle scoped packages: @scope/name@version
-	if (spec.startsWith("@")) {
-		const lastAt = spec.lastIndexOf("@");
-		if (lastAt > 0) {
-			return {
-				name: spec.slice(0, lastAt),
-				version: spec.slice(lastAt + 1),
-			};
-		}
-		return { name: spec, version: "latest" };
-	}
-
-	// Handle regular packages: name@version
-	const atIndex = spec.indexOf("@");
-	if (atIndex > 0) {
-		return {
-			name: spec.slice(0, atIndex),
-			version: spec.slice(atIndex + 1),
-		};
-	}
-
-	return { name: spec, version: "latest" };
-}
-
 /**
  * Check if a path looks like a local path
  */
@@ -93,7 +245,7 @@ function isLocalPath(spec: string): boolean {
  * omp install [pkg...]
  */
 export async function installPlugin(packages?: string[], options: InstallOptions = {}): Promise<void> {
-	const isGlobal = options.global !== false; // Default to global
+	const isGlobal = resolveScope(options);
 	const prefix = isGlobal ? PLUGINS_DIR : ".pi";
 	const _nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
 
@@ -101,24 +253,29 @@ export async function installPlugin(packages?: string[], options: InstallOptions
 	if (isGlobal) {
 		await initGlobalPlugins();
 	} else {
-		// Ensure project .pi directory exists
-		await mkdir(prefix, { recursive: true });
-		// Initialize plugins.json if it doesn't exist
-		if (!existsSync(PROJECT_PLUGINS_JSON)) {
-			await savePluginsJson({ plugins: {} }, false);
-		}
+		// Initialize project .pi directory with both plugins.json and package.json
+		await initProjectPlugins();
 	}
 
 	// If no packages specified, install from plugins.json
 	if (!packages || packages.length === 0) {
 		const pluginsJson = await loadPluginsJson(isGlobal);
-		packages = Object.entries(pluginsJson.plugins).map(([name, version]) => `${name}@${version}`);
+		// Prefer locked versions for reproducible installs
+		const lockFile = await import("@omp/lockfile").then((m) => m.loadLockFile(isGlobal));
+		packages = await Promise.all(
+			Object.entries(pluginsJson.plugins).map(async ([name, version]) => {
+				// Use locked version if available for reproducibility
+				const lockedVersion = lockFile?.packages[name]?.version;
+				return `${name}@${lockedVersion || version}`;
+			}),
+		);
 
 		if (packages.length === 0) {
 			console.log(chalk.yellow("No plugins to install."));
 			console.log(
 				chalk.dim(isGlobal ? "Add plugins with: omp install <package>" : "Add plugins to .pi/plugins.json"),
 			);
+			process.exitCode = 1;
 			return;
 		}
 
@@ -132,6 +289,9 @@ export async function installPlugin(packages?: string[], options: InstallOptions
 
 	const results: Array<{ name: string; version: string; success: boolean; error?: string }> = [];
 
+	// Load plugins.json once for reinstall detection and config storage
+	let pluginsJson = await loadPluginsJson(isGlobal);
+
 	for (const spec of packages) {
 		// Check if it's a local path
 		if (isLocalPath(spec)) {
@@ -140,27 +300,98 @@ export async function installPlugin(packages?: string[], options: InstallOptions
 			continue;
 		}
 
-		const { name, version } = parsePackageSpec(spec);
+		const parsed = parsePackageSpecWithFeatures(spec);
+		const { name, version } = parsed;
 		const pkgSpec = version === "latest" ? name : `${name}@${version}`;
 
+		// Track installation state for rollback
+		let npmInstallSucceeded = false;
+		let createdSymlinks: string[] = [];
+		let resolvedVersion = version;
+
+		// Check if this is a reinstall (plugin already exists)
+		const isReinstall = existingPlugins.has(name) || !!pluginsJson.plugins[name];
+		const existingConfig = pluginsJson.config?.[name];
+
 		try {
 			console.log(chalk.blue(`\nInstalling ${pkgSpec}...`));
 
-			// 1. Resolve version from npm registry
+			// 1. Resolve version and fetch package metadata from npm registry
+			// npm info includes omp field if present in package.json
 			const info = await npmInfo(pkgSpec);
 			if (!info) {
 				console.log(chalk.red(`  ✗ Package not found: ${name}`));
+				process.exitCode = 1;
 				results.push({ name, version, success: false, error: "Package not found" });
 				continue;
 			}
+			resolvedVersion = info.version;
+
+			// 2. Check for conflicts BEFORE npm install using registry metadata
+			const skipDestinations = new Set<string>();
+			const preInstallPkgJson = info.omp?.install ? { name: info.name, version: info.version, omp: info.omp } : null;
+
+			if (preInstallPkgJson) {
+				// Check for intra-plugin duplicates first
+				const intraDupes = detectIntraPluginDuplicates(preInstallPkgJson);
+				if (intraDupes.length > 0) {
+					console.log(chalk.red(`  ✗ Plugin has duplicate destinations:`));
+					for (const dupe of intraDupes) {
+						console.log(chalk.red(`    ${dupe.dest} ← ${dupe.sources.join(", ")}`));
+					}
+					process.exitCode = 1;
+					results.push({ name, version: info.version, success: false, error: "Duplicate destinations in plugin" });
+					continue;
+				}
 
-			// 2. Check for conflicts before installing
-			// We need to fetch the package.json to check omp.install
-			// For now, we'll check after npm install and rollback if needed
+				const preInstallConflicts = detectConflicts(name, preInstallPkgJson, existingPlugins);
+
+				if (preInstallConflicts.length > 0 && !options.force) {
+					// Check for non-interactive terminal (CI environments)
+					if (!process.stdout.isTTY || !process.stdin.isTTY) {
+						console.log(chalk.red("Conflicts detected in non-interactive mode. Use --force to override."));
+						for (const conflict of preInstallConflicts) {
+							console.log(chalk.yellow(`  ⚠ ${formatConflicts([conflict])[0]}`));
+						}
+						process.exitCode = 1;
+						results.push({
+							name,
+							version: info.version,
+							success: false,
+							error: "Conflicts in non-interactive mode",
+						});
+						continue;
+					}
+
+					// Handle conflicts BEFORE downloading the package
+					let abort = false;
+					for (const conflict of preInstallConflicts) {
+						const choice = await promptConflictResolution(conflict);
+						if (choice === null) {
+							abort = true;
+							break;
+						}
+						// choice is 0-indexed: 0 = first plugin (existing), last index = new plugin
+						const newPluginIndex = conflict.plugins.length - 1;
+						if (choice !== newPluginIndex) {
+							// User chose an existing plugin, skip this destination
+							skipDestinations.add(conflict.dest);
+						}
+					}
 
-			// 3. npm install
+					if (abort) {
+						console.log(chalk.yellow(`  Aborted due to conflicts (before download)`));
+						process.exitCode = 1;
+						results.push({ name, version: info.version, success: false, error: "Conflicts" });
+						continue;
+					}
+				}
+			}
+
+			// 3. npm install - only reached if no conflicts or user resolved them
 			console.log(chalk.dim(`  Fetching from npm...`));
 			await npmInstall([pkgSpec], prefix, { save: options.save || isGlobal });
+			npmInstallSucceeded = true;
 
 			// 4. Read package.json from installed package
 			const pkgJson = await readPluginPackageJson(name, isGlobal);
@@ -170,55 +401,166 @@ export async function installPlugin(packages?: string[], options: InstallOptions
 				continue;
 			}
 
-			// 5. Check for conflicts
-			const conflicts = detectConflicts(name, pkgJson, existingPlugins);
-
-			if (conflicts.length > 0 && !options.force) {
-				// Handle conflicts
-				let abort = false;
-				for (const conflict of conflicts) {
-					const choice = await promptConflictResolution(conflict);
-					if (choice === null) {
-						abort = true;
-						break;
+			// 5. Re-check conflicts with full package.json if we didn't check pre-install
+			// This handles edge cases where omp field wasn't in registry metadata
+			if (!preInstallPkgJson) {
+				// Check for intra-plugin duplicates first
+				const intraDupes = detectIntraPluginDuplicates(pkgJson);
+				if (intraDupes.length > 0) {
+					console.log(chalk.red(`  ✗ Plugin has duplicate destinations:`));
+					for (const dupe of intraDupes) {
+						console.log(chalk.red(`    ${dupe.dest} ← ${dupe.sources.join(", ")}`));
 					}
-					// If user chose the new plugin, we continue
-					// If user chose existing plugin, we skip this destination
-					// For now, simplify: if not aborted, force overwrite
-				}
-
-				if (abort) {
-					console.log(chalk.yellow(`  Aborted due to conflicts`));
 					// Rollback: uninstall the package
-					execSync(`npm uninstall --prefix ${prefix} ${name}`, { stdio: "pipe" });
-					results.push({ name, version: info.version, success: false, error: "Conflicts" });
+					execFileSync("npm", ["uninstall", "--prefix", prefix, name], { stdio: "pipe" });
+					process.exitCode = 1;
+					results.push({ name, version: info.version, success: false, error: "Duplicate destinations in plugin" });
 					continue;
 				}
+
+				const conflicts = detectConflicts(name, pkgJson, existingPlugins);
+
+				if (conflicts.length > 0 && !options.force) {
+					// Check for non-interactive terminal (CI environments)
+					if (!process.stdout.isTTY || !process.stdin.isTTY) {
+						console.log(chalk.red("Conflicts detected in non-interactive mode. Use --force to override."));
+						for (const conflict of conflicts) {
+							console.log(chalk.yellow(`  ⚠ ${formatConflicts([conflict])[0]}`));
+						}
+						// Rollback: uninstall the package
+						execFileSync("npm", ["uninstall", "--prefix", prefix, name], { stdio: "pipe" });
+						process.exitCode = 1;
+						results.push({
+							name,
+							version: info.version,
+							success: false,
+							error: "Conflicts in non-interactive mode",
+						});
+						continue;
+					}
+
+					let abort = false;
+					for (const conflict of conflicts) {
+						const choice = await promptConflictResolution(conflict);
+						if (choice === null) {
+							abort = true;
+							break;
+						}
+						const newPluginIndex = conflict.plugins.length - 1;
+						if (choice !== newPluginIndex) {
+							skipDestinations.add(conflict.dest);
+						}
+					}
+
+					if (abort) {
+						console.log(chalk.yellow(`  Aborted due to conflicts`));
+						// Rollback: uninstall the package
+						execFileSync("npm", ["uninstall", "--prefix", prefix, name], { stdio: "pipe" });
+						process.exitCode = 1;
+						results.push({ name, version: info.version, success: false, error: "Conflicts" });
+						continue;
+					}
+				}
+			}
+
+			// 6. Resolve features and create symlinks
+			const { enabledFeatures, configToStore } = resolveFeatures(
+				pkgJson,
+				parsed,
+				existingConfig,
+				isReinstall,
+			);
+
+			// Log feature selection if plugin has features
+			const allFeatureNames = getAllFeatureNames(pkgJson);
+			if (allFeatureNames.length > 0) {
+				if (enabledFeatures.length === allFeatureNames.length) {
+					console.log(chalk.dim(`  Features: all (${enabledFeatures.join(", ")})`));
+				} else if (enabledFeatures.length === 0) {
+					console.log(chalk.dim(`  Features: none (core only)`));
+				} else {
+					console.log(chalk.dim(`  Features: ${enabledFeatures.join(", ")}`));
+				}
 			}
 
-			// 6. Create symlinks for omp.install entries
-			const _symlinkResult = await createPluginSymlinks(name, pkgJson, isGlobal);
+			// Create symlinks for omp.install entries (skip destinations user assigned to existing plugins)
+			const symlinkResult = await createPluginSymlinks(name, pkgJson, isGlobal, true, skipDestinations, enabledFeatures);
+			createdSymlinks = symlinkResult.created;
+
+			// 7. Process dependencies with omp field (with cycle detection)
+			await processOmpDependencies(pkgJson, isGlobal, new Set([name]));
+
+			// 8. Update manifest and config
+			// For global mode, npm --save already updates package.json dependencies
+			// but we need to handle devDependencies and config manually
+			// For project-local mode, we must manually update plugins.json
+			if (options.save || options.saveDev || configToStore) {
+				// Reload to avoid stale data if multiple packages are being installed
+				pluginsJson = await loadPluginsJson(isGlobal);
+				if (options.saveDev) {
+					// Save to devDependencies
+					if (!pluginsJson.devDependencies) {
+						pluginsJson.devDependencies = {};
+					}
+					pluginsJson.devDependencies[name] = info.version;
+					// Remove from plugins if it was there
+					delete pluginsJson.plugins[name];
+				} else if (!isGlobal) {
+					// Save to plugins (project-local mode only - npm handles global)
+					pluginsJson.plugins[name] = info.version;
+				}
 
-			// 7. Process dependencies with omp field
-			if (pkgJson.dependencies) {
-				for (const depName of Object.keys(pkgJson.dependencies)) {
-					const depPkgJson = await readPluginPackageJson(depName, isGlobal);
-					if (depPkgJson?.omp?.install) {
-						console.log(chalk.dim(`  Processing dependency: ${depName}`));
-						await createPluginSymlinks(depName, depPkgJson, isGlobal);
+				// Store feature config if changed
+				if (configToStore) {
+					if (!pluginsJson.config) {
+						pluginsJson.config = {};
 					}
+					pluginsJson.config[name] = {
+						...pluginsJson.config[name],
+						...configToStore,
+					};
 				}
+
+				await savePluginsJson(pluginsJson, isGlobal);
 			}
 
 			// Add to installed plugins map for subsequent conflict detection
 			existingPlugins.set(name, pkgJson);
 
+			// Update lock file with exact version
+			await updateLockFile(name, info.version, isGlobal);
+
 			console.log(chalk.green(`✓ Installed ${name}@${info.version}`));
 			results.push({ name, version: info.version, success: true });
 		} catch (err) {
 			const errorMsg = (err as Error).message;
 			console.log(chalk.red(`  ✗ Failed to install ${name}: ${errorMsg}`));
-			results.push({ name, version, success: false, error: errorMsg });
+
+			// Rollback: remove any symlinks that were created
+			if (createdSymlinks.length > 0) {
+				console.log(chalk.dim("  Rolling back symlinks..."));
+				const baseDir = isGlobal ? PI_CONFIG_DIR : PROJECT_PI_DIR;
+				for (const dest of createdSymlinks) {
+					try {
+						await rm(join(baseDir, dest), { force: true, recursive: true });
+					} catch {
+						// Ignore cleanup errors
+					}
+				}
+			}
+
+			// Rollback: uninstall npm package if it was installed
+			if (npmInstallSucceeded) {
+				console.log(chalk.dim("  Rolling back npm install..."));
+				try {
+					execFileSync("npm", ["uninstall", "--prefix", prefix, name], { stdio: "pipe" });
+				} catch {
+					// Ignore cleanup errors
+				}
+			}
+
+			process.exitCode = 1;
+			results.push({ name, version: resolvedVersion, success: false, error: errorMsg });
 		}
 	}
 
@@ -232,6 +574,7 @@ export async function installPlugin(packages?: string[], options: InstallOptions
 	}
 	if (failed.length > 0) {
 		console.log(chalk.red(`✗ Failed to install ${failed.length} plugin(s)`));
+		process.exitCode = 1;
 	}
 
 	if (options.json) {
@@ -255,6 +598,7 @@ async function installLocalPlugin(
 
 	if (!existsSync(localPath)) {
 		console.log(chalk.red(`Error: Path does not exist: ${localPath}`));
+		process.exitCode = 1;
 		return { name: basename(localPath), version: "local", success: false, error: "Path not found" };
 	}
 
@@ -295,6 +639,22 @@ async function installLocalPlugin(
 		const pluginName = pkgJson.name;
 		const pluginDir = join(nodeModules, pluginName);
 
+		// Check for intra-plugin duplicates
+		const intraDupes = detectIntraPluginDuplicates(pkgJson);
+		if (intraDupes.length > 0) {
+			console.log(chalk.red(`\nError: Plugin has duplicate destinations:`));
+			for (const dupe of intraDupes) {
+				console.log(chalk.red(`  ${dupe.dest} ← ${dupe.sources.join(", ")}`));
+			}
+			process.exitCode = 1;
+			return {
+				name: pluginName,
+				version: pkgJson.version,
+				success: false,
+				error: "Duplicate destinations in plugin",
+			};
+		}
+
 		console.log(chalk.blue(`\nInstalling ${pluginName} from ${localPath}...`));
 
 		// Create node_modules directory
@@ -311,17 +671,30 @@ async function installLocalPlugin(
 
 		// Update plugins.json/package.json
 		const pluginsJson = await loadPluginsJson(isGlobal);
-		pluginsJson.plugins[pluginName] = `file:${localPath}`;
+		if (_options.saveDev) {
+			if (!pluginsJson.devDependencies) {
+				pluginsJson.devDependencies = {};
+			}
+			pluginsJson.devDependencies[pluginName] = `file:${localPath}`;
+			// Remove from plugins if it was there
+			delete pluginsJson.plugins[pluginName];
+		} else {
+			pluginsJson.plugins[pluginName] = `file:${localPath}`;
+		}
 		await savePluginsJson(pluginsJson, isGlobal);
 
 		// Create symlinks
 		await createPluginSymlinks(pluginName, pkgJson, isGlobal);
 
+		// Update lock file for local plugin
+		await updateLockFile(pluginName, pkgJson.version, isGlobal);
+
 		console.log(chalk.green(`✓ Installed ${pluginName}@${pkgJson.version}`));
 		return { name: pluginName, version: pkgJson.version, success: true };
 	} catch (err) {
 		const errorMsg = (err as Error).message;
 		console.log(chalk.red(`  ✗ Failed: ${errorMsg}`));
+		process.exitCode = 1;
 		return { name: basename(localPath), version: "local", success: false, error: errorMsg };
 	}
 }