@launch77/cli 1.7.2 → 1.7.3

package/src/modules/plugin/errors/plugin-errors.ts

@@ -1,145 +0,0 @@
-export class PluginNotFoundError extends Error {
-  constructor(pluginName: string) {
-    super(`Plugin '${pluginName}' not found.
-
-Run 'launch77 plugin:list' to see available plugins.`)
-    this.name = 'PluginNotFoundError'
-  }
-}
-
-export class InvalidPluginContextError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'InvalidPluginContextError'
-  }
-}
-
-/**
- * Factory function to create standardized InvalidPluginContextError
- * for when plugin:install is run outside of a package directory
- */
-export function createInvalidContextError(currentLocation: string): InvalidPluginContextError {
-  return new InvalidPluginContextError(
-    `plugin:install must be run from within a package directory.
-
-Current location: ${currentLocation}
-Expected: apps/<name>/, libraries/<name>/, plugins/<name>/, or app-templates/<name>/
-
-Navigate to a package directory:
-  cd apps/<app-name>/
-  cd libraries/<lib-name>/
-  cd plugins/<plugin-name>/
-  cd app-templates/<template-name>/`
-  )
-}
-
-/**
- * Error when plugin.json is missing the required 'targets' field
- */
-export class MissingPluginTargetsError extends Error {
-  constructor(pluginName: string) {
-    super(`Plugin '${pluginName}' is missing the required 'targets' field in plugin.json.
-
-The plugin.json file must include a 'targets' array specifying which package types
-the plugin can be installed into.
-
-Example plugin.json:
-{
-  "name": "${pluginName}",
-  "version": "1.0.0",
-  "targets": ["app", "library", "plugin", "app-template"],
-  "pluginDependencies": {},
-  "libraryDependencies": {}
-}`)
-    this.name = 'MissingPluginTargetsError'
-  }
-}
-
-/**
- * Factory function to create error when plugin targets don't match current location
- */
-export function createInvalidTargetError(pluginName: string, currentTarget: string, allowedTargets: string[]): InvalidPluginContextError {
-  const targetLocations = allowedTargets.map((target) => {
-    switch (target) {
-      case 'app':
-        return 'apps/<name>/'
-      case 'library':
-        return 'libraries/<name>/'
-      case 'plugin':
-        return 'plugins/<name>/'
-      case 'app-template':
-        return 'app-templates/<name>/'
-      default:
-        return target
-    }
-  })
-
-  return new InvalidPluginContextError(
-    `Plugin '${pluginName}' cannot be installed in a '${currentTarget}' package.
-
-This plugin can only be installed in: ${allowedTargets.join(', ')}
-
-Allowed locations:
-${targetLocations.map((loc) => `  ${loc}`).join('\n')}`
-  )
-}
-
-export class PluginInstallationError extends Error {
-  constructor(
-    message: string,
-    public readonly cause?: Error
-  ) {
-    super(message)
-    this.name = 'PluginInstallationError'
-  }
-}
-
-/**
- * Error when plugin resolution fails
- */
-export class PluginResolutionError extends Error {
-  constructor(pluginName: string, reason: string) {
-    super(`Failed to resolve plugin '${pluginName}': ${reason}`)
-    this.name = 'PluginResolutionError'
-  }
-}
-
-/**
- * Error when npm package installation fails
- */
-export class NpmInstallationError extends Error {
-  constructor(
-    packageName: string,
-    public readonly cause?: Error
-  ) {
-    super(`Failed to install npm package '${packageName}'.
-
-Please check:
-- Your internet connection
-- npm registry access (https://registry.npmjs.org)
-- Package exists: https://www.npmjs.com/package/${packageName}
-
-${cause ? `\nOriginal error: ${cause.message}` : ''}`)
-    this.name = 'NpmInstallationError'
-  }
-}
-
-/**
- * Error when plugin directory is not found for deletion
- */
-export class PluginDirectoryNotFoundError extends Error {
-  constructor(pluginName: string, expectedPath: string) {
-    super(`Plugin '${pluginName}' does not exist.\n\n` + `Expected location: ${expectedPath}\n\n` + `Available plugins:\n` + `  cd plugins/\n` + `  ls`)
-    this.name = 'PluginDirectoryNotFoundError'
-  }
-}
-
-/**
- * Error when plugin name validation fails
- */
-export class InvalidPluginNameError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'InvalidPluginNameError'
-  }
-}

package/src/modules/plugin/lib/plugin-resolver.ts

@@ -1,41 +0,0 @@
-import * as path from 'path'
-
-import fs from 'fs-extra'
-
-import { PackageResolver } from '../../../infrastructure/package-resolver.js'
-
-/**
- * Plugin resolver implementation
- *
- * Resolves plugins from:
- * - Local workspace plugins/ directory
- * - npm packages with @launch77-shared/plugin- prefix
- */
-export class PluginResolver extends PackageResolver {
-  protected getFolderName(): string {
-    return 'plugins'
-  }
-
-  protected getPackagePrefix(): string {
-    return '@launch77-shared/plugin-'
-  }
-
-  protected async verify(localPath: string): Promise<boolean> {
-    // Verify it's a valid plugin (has plugin.json, dist/generator.js, and package.json with version)
-    const hasPluginJson = await fs.pathExists(path.join(localPath, 'plugin.json'))
-    const hasGenerator = await fs.pathExists(path.join(localPath, 'dist/generator.js'))
-    const hasPackageJson = await fs.pathExists(path.join(localPath, 'package.json'))
-
-    if (!hasPluginJson || !hasGenerator || !hasPackageJson) {
-      return false
-    }
-
-    // Verify package.json has a version field
-    try {
-      const packageJson = await fs.readJson(path.join(localPath, 'package.json'))
-      return !!packageJson.version
-    } catch {
-      return false
-    }
-  }
-}

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

@@ -1,303 +0,0 @@
-import * as path from 'path'
-import * as fs from 'fs/promises'
-
-import chalk from 'chalk'
-import { execa } from 'execa'
-import fsExtra from 'fs-extra'
-import { readPluginMetadata } from '@launch77/plugin-runtime'
-
-import { downloadNpmPackage } from '../../../infrastructure/npm-package.js'
-import * as npm from '../../../infrastructure/npm.js'
-import { validateWorkspaceContext } from '../../../utils/launch77-validation.js'
-import { validateAppName } from '../../../utils/validation.js'
-import { PluginInstallationError, InvalidPluginContextError, createInvalidContextError, MissingPluginTargetsError, createInvalidTargetError, NpmInstallationError, PluginResolutionError, PluginDirectoryNotFoundError, InvalidPluginNameError } from '../errors/plugin-errors.js'
-import { PluginResolver } from '../lib/plugin-resolver.js'
-
-import type { Launch77Context, Launch77LocationType, Launch77PackageManifest, InstalledPluginMetadata, PluginMetadata } from '@launch77/plugin-runtime'
-import type { InstallPluginRequest, InstallPluginResult, DeletePluginRequest, DeletePluginResult } from '../types/plugin-types.js'
-
-/**
- * Map location type to target string
- */
-function locationTypeToTarget(locationType: Launch77LocationType): string | null {
-  switch (locationType) {
-    case 'workspace-app':
-      return 'app'
-    case 'workspace-library':
-      return 'library'
-    case 'workspace-plugin':
-      return 'plugin'
-    case 'workspace-app-template':
-      return 'app-template'
-    default:
-      return null
-  }
-}
-
-export class PluginService {
-  private pluginResolver: PluginResolver
-
-  constructor() {
-    this.pluginResolver = new PluginResolver()
-  }
-
-  /**
-   * Validate that we're in a valid package directory and return the target type
-   */
-  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
-  }
-
-  /**
-   * 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; version: string }> {
-    logger(chalk.blue(`\n🔍 Resolving plugin "${pluginName}"...`))
-    logger(`  ├─ Validating plugin name...`)
-
-    const validation = this.pluginResolver.validateInput(pluginName)
-    if (!validation.isValid) {
-      throw new PluginResolutionError(pluginName, validation.error || 'Invalid plugin name')
-    }
-    logger(`  │  └─ ${chalk.green('✓')} Valid plugin name`)
-
-    logger(`  ├─ Checking local workspace: ${chalk.dim(`plugins/${pluginName}`)}`)
-    const resolution = await this.pluginResolver.resolveLocation(pluginName, workspaceRoot)
-
-    let pluginPath: string
-    let version: string
-
-    if (resolution.source === 'local') {
-      logger(`  │  └─ ${chalk.green('✓')} Found local plugin`)
-      pluginPath = resolution.localPath!
-      version = resolution.version! // Local plugins always have version after verification
-    } else {
-      logger(`  │  └─ ${chalk.dim('Not found locally')}`)
-      logger(`  ├─ Resolving to npm package: ${chalk.cyan(resolution.npmPackage)}`)
-
-      pluginPath = await this.downloadNpmPlugin(resolution.npmPackage!, workspaceRoot, logger)
-
-      // Read version from downloaded package
-      const packageJsonPath = path.join(pluginPath, 'package.json')
-      const packageJsonContent = await fs.readFile(packageJsonPath, 'utf-8')
-      const packageJson = JSON.parse(packageJsonContent)
-      version = packageJson.version
-    }
-
-    logger(`  └─ ${chalk.green('✓')} Plugin resolved\n`)
-
-    return {
-      pluginPath,
-      source: resolution.source,
-      npmPackage: resolution.npmPackage,
-      version,
-    }
-  }
-
-  /**
-   * 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) {
-      throw new MissingPluginTargetsError(pluginName)
-    }
-
-    if (!metadata.targets.includes(currentTarget)) {
-      throw createInvalidTargetError(pluginName, currentTarget, metadata.targets)
-    }
-
-    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, version } = 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
-
-    await this.runGenerator(pluginPath, packagePath, context)
-
-    const packageName = source === 'npm' ? npmPackage! : pluginName
-    await this.writePluginManifest(packagePath, {
-      pluginName,
-      packageName,
-      version,
-      source,
-    })
-
-    return {
-      pluginName,
-      filesInstalled: true,
-      packageJsonUpdated: true,
-      dependenciesInstalled: true,
-    }
-  }
-
-  /**
-   * Download and install an npm plugin package
-   */
-  private async downloadNpmPlugin(npmPackage: string, workspaceRoot: string, logger: (message: string) => void): Promise<string> {
-    logger(`  └─ Installing from npm: ${chalk.cyan(npmPackage)}...`)
-
-    const result = await downloadNpmPackage({
-      packageName: npmPackage,
-      workspaceRoot,
-    })
-
-    return result.packagePath
-  }
-
-  private getPackagePath(context: Launch77Context): string {
-    // Determine the base directory based on location type
-    switch (context.locationType) {
-      case 'workspace-app':
-        return path.join(context.appsDir, context.appName!)
-      case 'workspace-library':
-        return path.join(context.workspaceRoot, 'libraries', context.appName!)
-      case 'workspace-plugin':
-        return path.join(context.workspaceRoot, 'plugins', context.appName!)
-      case 'workspace-app-template':
-        return path.join(context.workspaceRoot, 'app-templates', context.appName!)
-      default:
-        throw new InvalidPluginContextError(`Cannot install plugin from ${context.locationType}`)
-    }
-  }
-
-  private async runGenerator(pluginPath: string, appPath: string, context: Launch77Context): Promise<void> {
-    try {
-      const generatorPath = path.join(pluginPath, 'dist/generator.js')
-
-      const args = [generatorPath, `--appPath=${appPath}`, `--appName=${context.appName}`, `--workspaceName=${context.workspaceName}`, `--pluginPath=${pluginPath}`]
-
-      await execa('node', args, {
-        cwd: pluginPath,
-        stdio: 'inherit',
-      })
-    } catch (error) {
-      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)
-    }
-  }
-
-  /**
-   * Delete a plugin from the workspace
-   */
-  async deletePlugin(request: DeletePluginRequest, context: Launch77Context): Promise<DeletePluginResult> {
-    const { pluginName } = request
-
-    // 1. Validate plugin name (reusing app name validation since format is the same)
-    const nameValidation = validateAppName(pluginName)
-    if (!nameValidation.valid) {
-      throw new InvalidPluginNameError(nameValidation.errorMessage || 'Invalid plugin name')
-    }
-
-    // 2. Validate workspace context
-    const contextValidation = validateWorkspaceContext(context)
-    if (!contextValidation.valid) {
-      throw new Error(contextValidation.errorMessage || 'Invalid workspace context')
-    }
-
-    // 3. Determine plugin path
-    const pluginPath = path.join(context.workspaceRoot, 'plugins', pluginName)
-
-    // 4. Check if plugin exists
-    if (!(await fsExtra.pathExists(pluginPath))) {
-      throw new PluginDirectoryNotFoundError(pluginName, pluginPath)
-    }
-
-    // 5. Delete the plugin directory
-    await fsExtra.remove(pluginPath)
-
-    // 6. Update dependencies
-    await npm.install(context.workspaceRoot)
-
-    return {
-      pluginName,
-    }
-  }
-}

package/src/modules/plugin/types/plugin-types.ts

@@ -1,29 +0,0 @@
-export interface InstallPluginRequest {
-  pluginName: string
-}
-
-export interface InstallPluginResult {
-  pluginName: string
-  filesInstalled: boolean
-  packageJsonUpdated: boolean
-  dependenciesInstalled: boolean
-}
-
-export interface PluginMetadata {
-  dependencies?: Record<string, string>
-  devDependencies?: Record<string, string>
-  scripts?: Record<string, string>
-}
-
-export interface HookResult {
-  templateVariables?: Record<string, string>
-  hookContext?: Record<string, string>
-}
-
-export interface DeletePluginRequest {
-  pluginName: string
-}
-
-export interface DeletePluginResult {
-  pluginName: string
-}