@launch77/cli 1.4.0 → 1.4.3

package/src/modules/plugin/services/plugin-svc.ts

@@ -1,4 +1,5 @@
 import * as path from 'path'
+import * as fs from 'fs/promises'
 
 import chalk from 'chalk'
 import { execa } from 'execa'
@@ -7,7 +8,7 @@ import { readPluginMetadata } from '@launch77/plugin-runtime'
 import { PluginInstallationError, InvalidPluginContextError, createInvalidContextError, MissingPluginTargetsError, createInvalidTargetError, NpmInstallationError, PluginResolutionError } from '../errors/plugin-errors.js'
 import { validatePluginInput, resolvePluginLocation } from '../lib/plugin-resolver.js'
 
-import type { Launch77Context, Launch77LocationType } from '@launch77/plugin-runtime'
+import type { Launch77Context, Launch77LocationType, Launch77PackageManifest, InstalledPluginMetadata, PluginMetadata } from '@launch77/plugin-runtime'
 import type { InstallPluginRequest, InstallPluginResult } from '../types/plugin-types.js'
 
 /**
@@ -30,17 +31,19 @@ function locationTypeToTarget(locationType: Launch77LocationType): string | null
 
 export class PluginService {
   /**
-   * Install a plugin to the current package
+   * Validate that we're in a valid package directory and return the target type
    */
-  async installPlugin(request: InstallPluginRequest, context: Launch77Context, logger: (message: string) => void = console.log): Promise<InstallPluginResult> {
-    const { pluginName } = request
-
-    // Must be in a package directory (app, library, plugin, or app-template)
+  private validateContext(context: Launch77Context): string {
     const currentTarget = locationTypeToTarget(context.locationType)
     if (!currentTarget) throw createInvalidContextError(context.locationType)
     if (!context.appName) throw new InvalidPluginContextError('Could not determine package name. This is a bug. Please report it.')
+    return currentTarget
+  }
 
-    // Step 1: Validate plugin input
+  /**
+   * Validate plugin name, resolve its location, and download if needed
+   */
+  private async validateAndResolvePlugin(pluginName: string, workspaceRoot: string, logger: (message: string) => void): Promise<{ pluginPath: string; source: 'local' | 'npm'; npmPackage?: string }> {
     logger(chalk.blue(`\n🔍 Resolving plugin "${pluginName}"...`))
     logger(`  ├─ Validating plugin name...`)
 
@@ -50,9 +53,8 @@ export class PluginService {
     }
     logger(`  │  └─ ${chalk.green('✓')} Valid plugin name`)
 
-    // Step 2: Resolve plugin location
     logger(`  ├─ Checking local workspace: ${chalk.dim(`plugins/${pluginName}`)}`)
-    const resolution = await resolvePluginLocation(pluginName, context.workspaceRoot)
+    const resolution = await resolvePluginLocation(pluginName, workspaceRoot)
 
     let pluginPath: string
 
@@ -63,13 +65,22 @@ export class PluginService {
       logger(`  │  └─ ${chalk.dim('Not found locally')}`)
       logger(`  ├─ Resolving to npm package: ${chalk.cyan(resolution.npmPackage)}`)
 
-      // Download npm plugin
-      pluginPath = await this.downloadNpmPlugin(resolution.npmPackage!, context.workspaceRoot, logger)
+      pluginPath = await this.downloadNpmPlugin(resolution.npmPackage!, workspaceRoot, logger)
     }
 
     logger(`  └─ ${chalk.green('✓')} Plugin resolved\n`)
 
-    // Step 3: Read plugin metadata and validate targets
+    return {
+      pluginPath,
+      source: resolution.source,
+      npmPackage: resolution.npmPackage,
+    }
+  }
+
+  /**
+   * Read plugin metadata and validate it supports the current target
+   */
+  private async validatePluginTargets(pluginPath: string, pluginName: string, currentTarget: string): Promise<PluginMetadata> {
     const metadata = await readPluginMetadata(pluginPath)
 
     if (!metadata.targets || metadata.targets.length === 0) {
@@ -80,12 +91,55 @@ export class PluginService {
       throw createInvalidTargetError(pluginName, currentTarget, metadata.targets)
     }
 
-    // Step 4: Get package directory path
+    return metadata
+  }
+
+  /**
+   * Check if plugin is already installed and return early-exit result if so
+   */
+  private async checkExistingInstallation(pluginName: string, packagePath: string, logger: (message: string) => void): Promise<InstallPluginResult | null> {
+    const existingInstallation = await this.isPluginInstalled(pluginName, packagePath)
+    if (existingInstallation) {
+      logger(chalk.yellow(`\nℹ️  Plugin '${pluginName}' is already installed in this package.\n`))
+      logger(`Package: ${chalk.cyan(existingInstallation.package)} (${existingInstallation.source})`)
+      logger(`Version: ${existingInstallation.version}`)
+      logger(`Installed: ${existingInstallation.installedAt}\n`)
+      logger(chalk.gray('To reinstall: Remove from package.json launch77.installedPlugins'))
+      logger(chalk.gray('(plugin:remove command coming soon)\n'))
+      return {
+        pluginName,
+        filesInstalled: false,
+        packageJsonUpdated: false,
+        dependenciesInstalled: false,
+      }
+    }
+    return null
+  }
+
+  /**
+   * Install a plugin to the current package
+   */
+  async installPlugin(request: InstallPluginRequest, context: Launch77Context, logger: (message: string) => void = console.log): Promise<InstallPluginResult> {
+    const { pluginName } = request
+
+    const currentTarget = this.validateContext(context)
+    const { pluginPath, source, npmPackage } = await this.validateAndResolvePlugin(pluginName, context.workspaceRoot, logger)
+    const metadata = await this.validatePluginTargets(pluginPath, pluginName, currentTarget)
+
     const packagePath = this.getPackagePath(context)
+    const earlyExit = await this.checkExistingInstallation(pluginName, packagePath, logger)
+    if (earlyExit) return earlyExit
 
-    // Step 5: Run generator
     await this.runGenerator(pluginPath, packagePath, context)
 
+    const packageName = source === 'npm' ? npmPackage! : pluginName
+    await this.writePluginManifest(packagePath, {
+      pluginName,
+      packageName,
+      version: metadata.version,
+      source,
+    })
+
     return {
       pluginName,
       filesInstalled: true,
@@ -135,7 +189,9 @@ export class PluginService {
     try {
       const generatorPath = path.join(pluginPath, 'dist/generator.js')
 
-      await execa('node', [generatorPath, `--appPath=${appPath}`, `--appName=${context.appName}`, `--workspaceName=${context.workspaceName}`, `--pluginPath=${pluginPath}`], {
+      const args = [generatorPath, `--appPath=${appPath}`, `--appName=${context.appName}`, `--workspaceName=${context.workspaceName}`, `--pluginPath=${pluginPath}`]
+
+      await execa('node', args, {
         cwd: pluginPath,
         stdio: 'inherit',
       })
@@ -143,4 +199,55 @@ export class PluginService {
       throw new PluginInstallationError(`Generator failed: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined)
     }
   }
+
+  private async isPluginInstalled(pluginName: string, packagePath: string): Promise<InstalledPluginMetadata | null> {
+    try {
+      const packageJsonPath = path.join(packagePath, 'package.json')
+      const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8')
+      const packageJson = JSON.parse(packageJsonContent)
+
+      const manifest = packageJson.launch77 as Launch77PackageManifest | undefined
+
+      if (manifest?.installedPlugins?.[pluginName]) {
+        return manifest.installedPlugins[pluginName]
+      }
+
+      return null
+    } catch (error) {
+      // If package.json doesn't exist or can't be read, assume not installed
+      return null
+    }
+  }
+
+  /**
+   * Write plugin installation metadata to the target package's package.json
+   */
+  private async writePluginManifest(packagePath: string, installationInfo: { pluginName: string; packageName: string; version: string; source: 'local' | 'npm' }): Promise<void> {
+    try {
+      const packageJsonPath = path.join(packagePath, 'package.json')
+      const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8')
+      const packageJson = JSON.parse(packageJsonContent)
+
+      if (!packageJson.launch77) {
+        packageJson.launch77 = {}
+      }
+
+      if (!packageJson.launch77.installedPlugins) {
+        packageJson.launch77.installedPlugins = {}
+      }
+
+      const manifest = packageJson.launch77 as Launch77PackageManifest
+
+      manifest.installedPlugins![installationInfo.pluginName] = {
+        package: installationInfo.packageName,
+        version: installationInfo.version,
+        installedAt: new Date().toISOString(),
+        source: installationInfo.source,
+      }
+
+      await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8')
+    } catch (error) {
+      throw new PluginInstallationError(`Failed to write plugin manifest: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined)
+    }
+  }
 }

package/templates/workspace/package.json

@@ -19,7 +19,8 @@
     "changeset": "changeset",
     "version-packages": "changeset version",
     "release": "turbo run build lint typecheck test && changeset publish",
-    "prepare": "husky"
+    "prepare": "husky",
+    "clean": "rm -rf node_modules apps/*/node_modules libraries/*/node_modules plugins/*/node_modules app-templates/*/node_modules package-lock.json apps/*/package-lock.json libraries/*/package-lock.json plugins/*/package-lock.json app-templates/*/package-lock.json dist apps/*/dist libraries/*/dist plugins/*/dist app-templates/*/dist .next apps/*/.next .turbo apps/*/.turbo libraries/*/.turbo plugins/*/.turbo app-templates/*/.turbo build apps/*/build out apps/*/out coverage apps/*/coverage .cache *.log .eslintcache"
   },
   "devDependencies": {
     "@changesets/cli": "^2.29.8",