@launch77/plugin-runtime 0.3.2 → 0.3.3

package/dist/index.js

@@ -1,65 +1,469 @@
-// src/generator.ts
+// src/modules/workspace/services/workspace-service.ts
+import * as path3 from "path";
+
+// src/modules/workspace/services/workspace-manifest-service.ts
+import * as path from "path";
+import fs from "fs-extra";
+var _WorkspaceManifestService = class _WorkspaceManifestService {
+  /**
+   * Check if a workspace manifest exists at the given root
+   */
+  async exists(workspaceRoot) {
+    const manifestPath = path.join(workspaceRoot, _WorkspaceManifestService.WORKSPACE_MANIFEST);
+    return await fs.pathExists(manifestPath);
+  }
+  /**
+   * Read the workspace manifest
+   */
+  async readWorkspaceManifest(workspaceRoot) {
+    const manifestPath = path.join(workspaceRoot, _WorkspaceManifestService.WORKSPACE_MANIFEST);
+    if (!await fs.pathExists(manifestPath)) {
+      return null;
+    }
+    try {
+      return await fs.readJSON(manifestPath);
+    } catch (error) {
+      throw new Error(`Failed to read workspace manifest: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Write the workspace manifest
+   */
+  async writeWorkspaceManifest(workspaceRoot, manifest) {
+    const manifestPath = path.join(workspaceRoot, _WorkspaceManifestService.WORKSPACE_MANIFEST);
+    try {
+      await fs.ensureDir(path.dirname(manifestPath));
+      await fs.writeJSON(manifestPath, manifest, { spaces: 2 });
+    } catch (error) {
+      throw new Error(`Failed to write workspace manifest: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Get the manifest file path for a workspace
+   */
+  getManifestPath(workspaceRoot) {
+    return path.join(workspaceRoot, _WorkspaceManifestService.WORKSPACE_MANIFEST);
+  }
+};
+_WorkspaceManifestService.WORKSPACE_MANIFEST = ".launch77/workspace.json";
+var WorkspaceManifestService = _WorkspaceManifestService;
+
+// src/modules/workspace/utils/location-parser.ts
+import * as path2 from "path";
+function parseLocationFromPath(cwdPath, workspaceRoot) {
+  const relativePath = path2.relative(workspaceRoot, cwdPath);
+  if (!relativePath || relativePath === ".") {
+    return { locationType: "workspace-root" };
+  }
+  const parts = relativePath.split(path2.sep);
+  if (parts[0] === "apps" && parts.length >= 2) {
+    return {
+      locationType: "workspace-app",
+      appName: parts[1]
+    };
+  }
+  if (parts[0] === "libraries" && parts.length >= 2) {
+    return {
+      locationType: "workspace-library",
+      appName: parts[1]
+    };
+  }
+  if (parts[0] === "plugins" && parts.length >= 2) {
+    return {
+      locationType: "workspace-plugin",
+      appName: parts[1]
+    };
+  }
+  if (parts[0] === "app-templates" && parts.length >= 2) {
+    return {
+      locationType: "workspace-app-template",
+      appName: parts[1]
+    };
+  }
+  return { locationType: "workspace-root" };
+}
+
+// src/modules/workspace/services/workspace-service.ts
+var WorkspaceService = class {
+  constructor(workspaceManifestService) {
+    this.workspaceManifestService = workspaceManifestService || new WorkspaceManifestService();
+  }
+  /**
+   * Check if a directory is a Launch77 workspace root
+   */
+  async isWorkspaceRoot(dir) {
+    return await this.workspaceManifestService.exists(dir);
+  }
+  /**
+   * Get the workspace root directory from the current directory
+   */
+  async findWorkspaceRoot(startDir) {
+    let currentDir = path3.resolve(startDir);
+    while (currentDir !== path3.dirname(currentDir)) {
+      if (await this.isWorkspaceRoot(currentDir)) {
+        return currentDir;
+      }
+      currentDir = path3.dirname(currentDir);
+    }
+    return null;
+  }
+  /**
+   * Validate that we're in a Launch77 workspace context
+   */
+  async validateWorkspaceContext(context) {
+    if (context.locationType === "unknown") {
+      return {
+        valid: false,
+        errorMessage: "Must be run from within a Launch77 workspace.\n\nCreate a workspace first:\n  launch77 init my-workspace\n  cd my-workspace"
+      };
+    }
+    return { valid: true };
+  }
+  /**
+   * Validate a workspace context using ValidationResult format
+   */
+  validateContext(context) {
+    if (context.locationType === "unknown") {
+      return {
+        isValid: false,
+        errors: ["Must be run from within a Launch77 workspace. Create a workspace first: launch77 init my-workspace"]
+      };
+    }
+    return { isValid: true };
+  }
+  /**
+   * Validate an app name
+   */
+  validateAppName(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+      return { isValid: false, errors: ["App name cannot be empty"] };
+    }
+    const validPattern = /^[a-z][a-z0-9-]*$/;
+    if (!validPattern.test(trimmed)) {
+      return {
+        isValid: false,
+        errors: ["App name must start with lowercase letter and contain only lowercase letters, numbers, and hyphens"]
+      };
+    }
+    if (trimmed.length > 50) {
+      return { isValid: false, errors: ["App name must be 50 characters or less"] };
+    }
+    return { isValid: true };
+  }
+  /**
+   * Detect the Launch77 workspace context from the current working directory
+   *
+   * @param cwd - Current working directory path
+   * @returns Context information about the workspace location
+   */
+  async detectLaunch77Context(cwd) {
+    const resolvedCwd = path3.resolve(cwd);
+    const workspaceRoot = await this.findWorkspaceRoot(resolvedCwd);
+    if (!workspaceRoot) {
+      return {
+        isValid: false,
+        locationType: "unknown",
+        workspaceRoot: "",
+        appsDir: "",
+        workspaceVersion: "",
+        workspaceName: "",
+        packageName: ""
+      };
+    }
+    let manifest;
+    try {
+      manifest = await this.workspaceManifestService.readWorkspaceManifest(workspaceRoot);
+      if (!manifest) {
+        return {
+          isValid: false,
+          locationType: "unknown",
+          workspaceRoot: "",
+          appsDir: "",
+          workspaceVersion: "",
+          workspaceName: "",
+          packageName: ""
+        };
+      }
+    } catch (error) {
+      return {
+        isValid: false,
+        locationType: "unknown",
+        workspaceRoot: "",
+        appsDir: "",
+        workspaceVersion: "",
+        workspaceName: "",
+        packageName: ""
+      };
+    }
+    const parsed = parseLocationFromPath(resolvedCwd, workspaceRoot);
+    const workspaceName = path3.basename(workspaceRoot);
+    const appsDir = path3.join(workspaceRoot, "apps");
+    const packageName = parsed.appName ? `@${workspaceName}/${parsed.appName}` : "";
+    return {
+      isValid: true,
+      locationType: parsed.locationType,
+      workspaceRoot,
+      appsDir,
+      workspaceVersion: manifest.version,
+      workspaceName,
+      appName: parsed.appName,
+      packageName
+    };
+  }
+};
+async function detectLaunch77Context(cwd) {
+  const service = new WorkspaceService();
+  return service.detectLaunch77Context(cwd);
+}
+
+// src/modules/plugin/generators/generator.ts
 var Generator = class {
   constructor(context) {
     this.context = context;
   }
 };
 
-// src/standard-generator.ts
-import * as path3 from "path";
-import * as fs3 from "fs/promises";
+// src/modules/plugin/generators/standard-generator.ts
+import * as fs4 from "fs/promises";
+import * as path6 from "path";
 import chalk from "chalk";
 import { execa } from "execa";
 
-// src/utils/file-operations.ts
-import * as fs from "fs/promises";
-import * as path from "path";
-async function copyRecursive(src, dest) {
-  const stat2 = await fs.stat(src);
-  if (stat2.isDirectory()) {
-    await fs.mkdir(dest, { recursive: true });
-    const entries = await fs.readdir(src);
-    for (const entry of entries) {
-      await copyRecursive(path.join(src, entry), path.join(dest, entry));
+// src/modules/filesystem/services/filesystem-service.ts
+import * as path4 from "path";
+import fs2 from "fs-extra";
+var FilesystemService = class {
+  /**
+   * Check if a path exists
+   */
+  async pathExists(filePath) {
+    try {
+      return await fs2.pathExists(filePath);
+    } catch {
+      return false;
     }
-  } else {
-    await fs.copyFile(src, dest);
   }
-}
-async function pathExists(filePath) {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
+  /**
+   * Copy a file or directory recursively
+   */
+  async copyRecursive(source, destination, options) {
+    try {
+      await fs2.copy(source, destination, {
+        overwrite: options?.overwrite ?? true,
+        errorOnExist: false
+      });
+    } catch (error) {
+      throw new Error(`Failed to copy from ${source} to ${destination}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
-}
+  /**
+   * Read a JSON file
+   */
+  async readJSON(filePath) {
+    try {
+      return await fs2.readJSON(filePath);
+    } catch (error) {
+      throw new Error(`Failed to read JSON from ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Write a JSON file
+   */
+  async writeJSON(filePath, data, options) {
+    try {
+      await fs2.writeJSON(filePath, data, { spaces: options?.spaces ?? 2 });
+    } catch (error) {
+      throw new Error(`Failed to write JSON to ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Read a text file
+   */
+  async readFile(filePath, encoding = "utf8") {
+    try {
+      return await fs2.readFile(filePath, encoding);
+    } catch (error) {
+      throw new Error(`Failed to read file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Write a text file
+   */
+  async writeFile(filePath, content, encoding = "utf8") {
+    try {
+      await fs2.writeFile(filePath, content, encoding);
+    } catch (error) {
+      throw new Error(`Failed to write file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Create a directory (including parent directories)
+   */
+  async ensureDir(dirPath) {
+    try {
+      await fs2.ensureDir(dirPath);
+    } catch (error) {
+      throw new Error(`Failed to create directory ${dirPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Remove a file or directory
+   */
+  async remove(filePath) {
+    try {
+      await fs2.remove(filePath);
+    } catch (error) {
+      throw new Error(`Failed to remove ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * List files in a directory
+   */
+  async readDir(dirPath) {
+    try {
+      return await fs2.readdir(dirPath);
+    } catch (error) {
+      throw new Error(`Failed to read directory ${dirPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Get file or directory stats
+   */
+  async getStats(filePath) {
+    try {
+      return await fs2.stat(filePath);
+    } catch (error) {
+      throw new Error(`Failed to get stats for ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Check if a path is a directory
+   */
+  async isDirectory(filePath) {
+    try {
+      const stats = await this.getStats(filePath);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if a path is a file
+   */
+  async isFile(filePath) {
+    try {
+      const stats = await this.getStats(filePath);
+      return stats.isFile();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Move a file or directory
+   */
+  async move(source, destination, options) {
+    try {
+      await fs2.move(source, destination, {
+        overwrite: options?.overwrite ?? false
+      });
+    } catch (error) {
+      throw new Error(`Failed to move from ${source} to ${destination}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Create a temporary directory
+   */
+  async createTempDir(prefix) {
+    const os2 = await import("os");
+    try {
+      return await fs2.mkdtemp(path4.join(os2.tmpdir(), prefix));
+    } catch (error) {
+      throw new Error(`Failed to create temp directory: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+};
 
-// src/utils/metadata.ts
-import * as fs2 from "fs/promises";
-import * as path2 from "path";
-async function readPluginMetadata(pluginPath) {
-  const metadataPath = path2.join(pluginPath, "plugin.json");
-  const content = await fs2.readFile(metadataPath, "utf-8");
-  const parsed = JSON.parse(content);
-  return {
-    targets: parsed.targets || [],
-    pluginDependencies: parsed.pluginDependencies,
-    libraryDependencies: parsed.libraryDependencies
-  };
-}
-async function readTemplateMetadata(templatePath) {
-  const templateJsonPath = path2.join(templatePath, "template.json");
-  try {
-    const content = await fs2.readFile(templateJsonPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
+// src/modules/plugin/services/metadata-service.ts
+import * as path5 from "path";
+import fs3 from "fs-extra";
+var MetadataService = class {
+  /**
+   * Read plugin metadata from a plugin directory
+   */
+  async readPluginMetadata(pluginPath) {
+    const metadataPath = path5.join(pluginPath, "plugin.json");
+    if (!await fs3.pathExists(metadataPath)) {
+      throw new Error(`Plugin metadata file not found at: ${metadataPath}`);
+    }
+    try {
+      const fullMetadata = await fs3.readJSON(metadataPath);
+      const { name: _name, version: _version, ...metadata } = fullMetadata;
+      return metadata;
+    } catch (error) {
+      throw new Error(`Failed to read plugin metadata: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
   }
-}
+  /**
+   * Read template metadata from a template directory
+   */
+  async readTemplateMetadata(templatePath) {
+    const metadataPath = path5.join(templatePath, "template.json");
+    if (!await fs3.pathExists(metadataPath)) {
+      throw new Error(`Template metadata file not found at: ${metadataPath}`);
+    }
+    try {
+      const metadata = await fs3.readJSON(metadataPath);
+      return metadata;
+    } catch (error) {
+      throw new Error(`Failed to read template metadata: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Check if a plugin metadata file exists
+   */
+  async hasPluginMetadata(pluginPath) {
+    const metadataPath = path5.join(pluginPath, "plugin.json");
+    return await fs3.pathExists(metadataPath);
+  }
+  /**
+   * Check if a template metadata file exists
+   */
+  async hasTemplateMetadata(templatePath) {
+    const metadataPath = path5.join(templatePath, "template.json");
+    return await fs3.pathExists(metadataPath);
+  }
+  /**
+   * Write plugin metadata to a directory
+   */
+  async writePluginMetadata(pluginPath, metadata) {
+    const metadataPath = path5.join(pluginPath, "plugin.json");
+    try {
+      await fs3.writeJSON(metadataPath, metadata, { spaces: 2 });
+    } catch (error) {
+      throw new Error(`Failed to write plugin metadata: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Write template metadata to a directory
+   */
+  async writeTemplateMetadata(templatePath, metadata) {
+    const metadataPath = path5.join(templatePath, "template.json");
+    try {
+      await fs3.writeJSON(metadataPath, metadata, { spaces: 2 });
+    } catch (error) {
+      throw new Error(`Failed to write template metadata: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+};
 
-// src/standard-generator.ts
+// src/modules/plugin/generators/standard-generator.ts
 var StandardGenerator = class extends Generator {
+  constructor(context) {
+    super(context);
+    this.filesystemService = new FilesystemService();
+    this.metadataService = new MetadataService();
+  }
   async run() {
     console.log(chalk.green(`
 \u2705 Installing plugin...
@@ -74,21 +478,21 @@ var StandardGenerator = class extends Generator {
     this.showNextSteps();
   }
   async updateDependencies() {
-    const pluginJsonPath = path3.join(this.context.pluginPath, "plugin.json");
-    if (!await pathExists(pluginJsonPath)) return;
+    const pluginJsonPath = path6.join(this.context.pluginPath, "plugin.json");
+    if (!await this.filesystemService.pathExists(pluginJsonPath)) return;
     try {
-      const pluginMetadata = await readPluginMetadata(this.context.pluginPath);
+      const pluginMetadata = await this.metadataService.readPluginMetadata(this.context.pluginPath);
       if (!pluginMetadata.libraryDependencies || Object.keys(pluginMetadata.libraryDependencies).length === 0) {
         return;
       }
-      const packageJsonPath = path3.join(this.context.appPath, "package.json");
-      const packageJsonContent = await fs3.readFile(packageJsonPath, "utf-8");
+      const packageJsonPath = path6.join(this.context.appPath, "package.json");
+      const packageJsonContent = await fs4.readFile(packageJsonPath, "utf-8");
       const packageJson = JSON.parse(packageJsonContent);
       packageJson.dependencies = {
         ...packageJson.dependencies,
         ...pluginMetadata.libraryDependencies
       };
-      await fs3.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+      await fs4.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
       console.log(chalk.green("   \u2713 Updated package.json with dependencies"));
     } catch (error) {
       console.log(chalk.yellow(`   \u26A0\uFE0F  Could not update dependencies: ${error}`));
@@ -97,7 +501,7 @@ var StandardGenerator = class extends Generator {
   async installDependencies() {
     try {
       console.log(chalk.cyan("   Installing dependencies..."));
-      const workspaceRoot = path3.dirname(path3.dirname(this.context.appPath));
+      const workspaceRoot = path6.dirname(path6.dirname(this.context.appPath));
       await execa("npm", ["install"], {
         cwd: workspaceRoot,
         stdio: "pipe"
@@ -108,10 +512,10 @@ var StandardGenerator = class extends Generator {
     }
   }
   async copyTemplates() {
-    const templatesDir = path3.join(this.context.pluginPath, "templates");
-    if (!await pathExists(templatesDir)) return;
+    const templatesDir = path6.join(this.context.pluginPath, "templates");
+    if (!await this.filesystemService.pathExists(templatesDir)) return;
     try {
-      await copyRecursive(templatesDir, this.context.appPath);
+      await this.filesystemService.copyRecursive(templatesDir, this.context.appPath);
       console.log(chalk.green("   \u2713 Copied template files"));
     } catch (error) {
       console.log(chalk.yellow(`   \u26A0\uFE0F  Could not copy template files: ${error}`));
@@ -123,288 +527,1232 @@ var StandardGenerator = class extends Generator {
   }
 };
 
-// src/context/index.ts
-import * as path6 from "path";
+// src/modules/plugin/services/plugin-service.ts
+import * as fs8 from "fs/promises";
+import * as path11 from "path";
+import chalk2 from "chalk";
+import { execa as execa4 } from "execa";
+import fsExtra from "fs-extra";
 
-// src/context/location-parser.ts
-import * as path4 from "path";
-function parseLocationFromPath(cwdPath, workspaceRoot) {
-  const relativePath = path4.relative(workspaceRoot, cwdPath);
-  if (!relativePath || relativePath === ".") {
-    return { locationType: "workspace-root" };
+// src/modules/npm/services/npm-service.ts
+import * as os from "os";
+import * as path7 from "path";
+import { execa as execa2 } from "execa";
+import fs5 from "fs-extra";
+var NpmService = class {
+  /**
+   * Validate an npm package name (scoped or unscoped)
+   *
+   * Rules for unscoped packages:
+   * - Must start with a lowercase letter
+   * - Can contain lowercase letters, numbers, hyphens, periods, underscores
+   *
+   * Rules for scoped packages:
+   * - Format: @org/package
+   * - Both org and package follow npm naming rules
+   *
+   * @param name - The npm package name to validate
+   * @returns ValidationResult indicating if valid and error message if not
+   */
+  validatePackageName(name) {
+    if (!name || name.trim().length === 0) {
+      return {
+        isValid: false,
+        error: "Package name cannot be empty"
+      };
+    }
+    const trimmedName = name.trim();
+    if (trimmedName.startsWith("@")) {
+      const scopedPattern = /^@([a-z0-9._-]+)\/([a-z0-9._-]+)$/;
+      if (!scopedPattern.test(trimmedName)) {
+        return {
+          isValid: false,
+          error: "Scoped package must be in format @org/package where org and package contain only lowercase letters, numbers, hyphens, periods, and underscores"
+        };
+      }
+      return { isValid: true };
+    }
+    const validPattern = /^[a-z0-9][a-z0-9._-]*$/;
+    if (!validPattern.test(trimmedName)) {
+      return {
+        isValid: false,
+        error: "Package name must be lowercase and contain only letters (a-z), numbers (0-9), hyphens (-), periods (.), and underscores (_)"
+      };
+    }
+    return { isValid: true };
   }
-  const parts = relativePath.split(path4.sep);
-  if (parts[0] === "apps" && parts.length >= 2) {
+  /**
+   * Parse a package name input and determine its type
+   *
+   * Returns information about whether the input is:
+   * - A scoped npm package (e.g., @org/package)
+   * - An unscoped name (e.g., my-package)
+   * - Invalid
+   */
+  parsePackageName(name) {
+    if (!name || name.trim().length === 0) {
+      return {
+        type: "invalid",
+        isValid: false,
+        error: "Package name cannot be empty"
+      };
+    }
+    const trimmedName = name.trim();
+    const validation = this.validatePackageName(trimmedName);
+    if (!validation.isValid) {
+      return {
+        type: "invalid",
+        isValid: false,
+        error: validation.error
+      };
+    }
+    if (trimmedName.startsWith("@")) {
+      const match = trimmedName.match(/^@([a-z0-9._-]+)\/([a-z0-9._-]+)$/);
+      if (match) {
+        return {
+          type: "scoped",
+          isValid: true,
+          name: trimmedName,
+          org: match[1],
+          package: match[2]
+        };
+      }
+    }
     return {
-      locationType: "workspace-app",
-      appName: parts[1]
+      type: "unscoped",
+      isValid: true,
+      name: trimmedName
     };
   }
-  if (parts[0] === "libraries" && parts.length >= 2) {
-    return {
-      locationType: "workspace-library",
-      appName: parts[1]
-    };
+  /**
+   * Install npm dependencies in a directory
+   */
+  async install(cwd) {
+    try {
+      await execa2("npm", ["install"], { cwd });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to install npm dependencies: ${message}`);
+    }
   }
-  if (parts[0] === "plugins" && parts.length >= 2) {
-    return {
-      locationType: "workspace-plugin",
-      appName: parts[1]
-    };
+  /**
+   * Install npm dependencies with legacy peer deps flag
+   */
+  async installWithLegacyPeerDeps(cwd) {
+    try {
+      await execa2("npm", ["install", "--legacy-peer-deps"], { cwd });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to install npm dependencies: ${message}`);
+    }
   }
-  if (parts[0] === "app-templates" && parts.length >= 2) {
-    return {
-      locationType: "workspace-app-template",
-      appName: parts[1]
-    };
+  /**
+   * Download an npm package to a temporary directory
+   */
+  async downloadPackage(options) {
+    const { packageName } = options;
+    const tempDir = await fs5.mkdtemp(path7.join(os.tmpdir(), "npm-download-"));
+    try {
+      const { stdout } = await execa2("npm", ["pack", packageName, "--json"], {
+        cwd: tempDir
+      });
+      const packResult = JSON.parse(stdout);
+      const tarballName = Array.isArray(packResult) ? packResult[0].filename : packResult.filename;
+      if (!tarballName) {
+        throw new Error("Failed to get tarball name from npm pack");
+      }
+      const tarballPath = path7.join(tempDir, tarballName);
+      await execa2("tar", ["-xzf", tarballPath], { cwd: tempDir });
+      const packagePath = path7.join(tempDir, "package");
+      const packageJsonPath = path7.join(packagePath, "package.json");
+      const packageJson = await fs5.readJSON(packageJsonPath);
+      return {
+        path: packagePath,
+        version: packageJson.version,
+        name: packageJson.name
+      };
+    } catch (error) {
+      await fs5.remove(tempDir).catch(() => {
+      });
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to download npm package '${packageName}': ${message}`);
+    }
   }
-  return { locationType: "workspace-root" };
-}
+  /**
+   * Get information about an npm package
+   */
+  async getPackageInfo(packageName) {
+    try {
+      const { stdout } = await execa2("npm", ["view", packageName, "--json"]);
+      return JSON.parse(stdout);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to get package info for '${packageName}': ${message}`);
+    }
+  }
+  /**
+   * Check if a package exists on npm
+   */
+  async packageExists(packageName) {
+    try {
+      await execa2("npm", ["view", packageName, "name"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Install a specific package as a dependency
+   */
+  async installPackage(packageName, cwd, isDev = false) {
+    try {
+      const args = ["install", packageName];
+      if (isDev) {
+        args.push("--save-dev");
+      }
+      await execa2("npm", args, { cwd });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to install package '${packageName}': ${message}`);
+    }
+  }
+  /**
+   * Uninstall a package
+   */
+  async uninstallPackage(packageName, cwd) {
+    try {
+      await execa2("npm", ["uninstall", packageName], { cwd });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      throw new Error(`Failed to uninstall package '${packageName}': ${message}`);
+    }
+  }
+  /**
+   * Clean up a temporary download directory
+   */
+  async cleanupDownload(downloadPath) {
+    const tempDir = path7.dirname(downloadPath);
+    if (tempDir.includes("npm-download-")) {
+      await fs5.remove(tempDir).catch(() => {
+      });
+    }
+  }
+};
 
-// src/context/manifest.ts
-import * as path5 from "path";
-import fs4 from "fs-extra";
-var WORKSPACE_MANIFEST = ".launch77/workspace.json";
-async function isWorkspaceRoot(dir) {
-  const manifestPath = path5.join(dir, WORKSPACE_MANIFEST);
-  return await fs4.pathExists(manifestPath);
-}
-async function readWorkspaceManifest(workspaceRoot) {
-  const manifestPath = path5.join(workspaceRoot, WORKSPACE_MANIFEST);
-  return await fs4.readJSON(manifestPath);
+// src/modules/npm/utils/npm-package.ts
+import * as path8 from "path";
+import { execa as execa3 } from "execa";
+
+// src/modules/plugin/errors/plugin-errors.ts
+var PluginNotFoundError = class extends Error {
+  constructor(pluginName) {
+    super(`Plugin '${pluginName}' not found.`);
+    this.name = "PluginNotFoundError";
+  }
+};
+var InvalidPluginContextError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidPluginContextError";
+  }
+};
+function createInvalidContextError(currentLocation) {
+  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>/`
+  );
 }
-async function findWorkspaceRoot(startDir) {
-  let currentDir = path5.resolve(startDir);
-  const rootDir = path5.parse(currentDir).root;
-  while (currentDir !== rootDir) {
-    if (await isWorkspaceRoot(currentDir)) {
-      return currentDir;
-    }
-    currentDir = path5.dirname(currentDir);
+var MissingPluginTargetsError = class extends Error {
+  constructor(pluginName) {
+    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";
   }
-  return null;
+};
+function createInvalidTargetError(pluginName, currentTarget, allowedTargets) {
+  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")}`
+  );
 }
+var PluginInstallationError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "PluginInstallationError";
+  }
+};
+var PluginResolutionError = class extends Error {
+  constructor(pluginName, reason) {
+    super(`Failed to resolve plugin '${pluginName}': ${reason}`);
+    this.name = "PluginResolutionError";
+  }
+};
+var NpmInstallationError = class extends Error {
+  constructor(packageName, cause) {
+    super(`Failed to install npm package '${packageName}'.
 
-// src/context/index.ts
-async function detectLaunch77Context(cwd) {
-  const resolvedCwd = path6.resolve(cwd);
-  const workspaceRoot = await findWorkspaceRoot(resolvedCwd);
-  if (!workspaceRoot) {
-    return {
-      isValid: false,
-      locationType: "unknown",
-      workspaceRoot: "",
-      appsDir: "",
-      workspaceVersion: "",
-      workspaceName: "",
-      packageName: ""
-    };
+Please check:
+- Your internet connection
+- npm registry access (https://registry.npmjs.org)
+- Package exists: https://www.npmjs.com/package/${packageName}
+
+${cause ? `
+Original error: ${cause.message}` : ""}`);
+    this.cause = cause;
+    this.name = "NpmInstallationError";
+  }
+};
+var PluginDirectoryNotFoundError = class extends Error {
+  constructor(pluginName, expectedPath) {
+    super(`Plugin '${pluginName}' does not exist.
+
+Expected location: ${expectedPath}
+
+Available plugins:
+  cd plugins/
+  ls`);
+    this.name = "PluginDirectoryNotFoundError";
+  }
+};
+var InvalidPluginNameError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidPluginNameError";
+  }
+};
+
+// src/modules/npm/utils/npm-package.ts
+async function downloadNpmPackage(options) {
+  const { packageName, workspaceRoot, logger } = options;
+  if (logger) {
+    logger(`Installing from npm: ${packageName}...`);
   }
-  let manifest;
   try {
-    manifest = await readWorkspaceManifest(workspaceRoot);
-  } catch (error) {
+    await execa3("npm", ["install", packageName, "--save-dev"], {
+      cwd: workspaceRoot,
+      stdio: "pipe"
+      // Capture output for clean logging
+    });
+    const packagePath = path8.join(workspaceRoot, "node_modules", packageName);
     return {
-      isValid: false,
-      locationType: "unknown",
-      workspaceRoot: "",
-      appsDir: "",
-      workspaceVersion: "",
-      workspaceName: "",
-      packageName: ""
+      packagePath,
+      packageName
     };
+  } catch (error) {
+    throw new NpmInstallationError(packageName, error instanceof Error ? error : void 0);
   }
-  const parsed = parseLocationFromPath(resolvedCwd, workspaceRoot);
-  const workspaceName = path6.basename(workspaceRoot);
-  const appsDir = path6.join(workspaceRoot, "apps");
-  const packageName = parsed.appName ? `@${workspaceName}/${parsed.appName}` : "";
-  return {
-    isValid: true,
-    locationType: parsed.locationType,
-    workspaceRoot,
-    appsDir,
-    workspaceVersion: manifest.version,
-    workspaceName,
-    appName: parsed.appName,
-    packageName
-  };
 }
 
-// src/utils/name-validation.ts
-function validatePluginName(name) {
-  if (!name || name.trim().length === 0) {
-    return {
-      isValid: false,
-      error: "Plugin name cannot be empty"
-    };
+// src/modules/plugin/resolvers/plugin-resolver.ts
+import * as path10 from "path";
+import fs7 from "fs-extra";
+
+// src/modules/npm/resolvers/package-resolver.ts
+import * as path9 from "path";
+import fs6 from "fs-extra";
+var PackageResolver = class {
+  constructor() {
+    this.npmService = new NpmService();
   }
-  const trimmedName = name.trim();
-  if (!/^[a-z]/.test(trimmedName)) {
-    return {
-      isValid: false,
-      error: "Plugin name must start with a lowercase letter (a-z)"
-    };
+  /**
+   * Validate package input name
+   *
+   * Accepts:
+   * - Unscoped names (e.g., "release", "my-package")
+   * - Scoped npm packages (e.g., "@ibm/package-name")
+   *
+   * Rejects:
+   * - Invalid formats
+   * - Empty strings
+   * - Names with invalid characters
+   *
+   * @param name - The package name to validate
+   * @returns ValidationResult with isValid and optional error message
+   *
+   * @example
+   * validateInput('release') // { isValid: true }
+   * validateInput('@ibm/analytics') // { isValid: true }
+   * validateInput('@invalid') // { isValid: false, error: '...' }
+   */
+  validateInput(name) {
+    if (!name || name.trim().length === 0) {
+      return {
+        isValid: false,
+        error: "Package name cannot be empty"
+      };
+    }
+    const trimmedName = name.trim();
+    const parsed = this.npmService.parsePackageName(trimmedName);
+    if (!parsed.isValid) {
+      return {
+        isValid: false,
+        error: parsed.error
+      };
+    }
+    if (parsed.type === "scoped") {
+      return this.npmService.validatePackageName(trimmedName);
+    }
+    return { isValid: true };
+  }
+  /**
+   * Convert an unscoped package name to an npm package name
+   *
+   * Rules:
+   * - Unscoped names: prefix with configured package prefix
+   * - Scoped names: use as-is
+   *
+   * @param name - The package name (must be validated first)
+   * @returns The npm package name
+   *
+   * @example
+   * toNpmPackageName('release') // '@launch77-shared/plugin-release' (for PluginResolver)
+   * toNpmPackageName('@ibm/analytics') // '@ibm/analytics'
+   */
+  toNpmPackageName(name) {
+    const trimmedName = name.trim();
+    if (trimmedName.startsWith("@")) {
+      return trimmedName;
+    }
+    return `${this.getPackagePrefix()}${trimmedName}`;
+  }
+  /**
+   * Read version from package.json
+   * @param packagePath - The path to the package directory
+   * @returns The version string from package.json
+   * @throws If package.json doesn't exist, can't be read, or is missing the version field
+   */
+  async readVersion(packagePath) {
+    const packageJsonPath = path9.join(packagePath, "package.json");
+    try {
+      const packageJson = await fs6.readJson(packageJsonPath);
+      if (!packageJson.version) {
+        throw new Error(`Invalid package structure: package.json at ${packagePath} is missing required version field. All Launch77 packages must include a valid package.json with a version field.`);
+      }
+      return packageJson.version;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Invalid package structure")) {
+        throw error;
+      }
+      throw new Error(`Invalid package structure: package.json not found or invalid at ${packagePath}. All Launch77 packages must include a valid package.json with a version field.`);
+    }
   }
-  if (!/^[a-z][a-z0-9-]*$/.test(trimmedName)) {
+  /**
+   * Resolve package location from name
+   *
+   * Resolution order:
+   * 1. Check local workspace directory (configured by getFolderName())
+   * 2. Verify local package is valid (using verify())
+   * 3. Fall back to npm package name (with configured prefix)
+   * 4. Read version from package.json (if available)
+   *
+   * @param name - The package name to resolve
+   * @param workspaceRoot - The workspace root directory
+   * @returns PackageResolution with source, resolved location, and version
+   *
+   * @example
+   * // Local package found
+   * await resolveLocation('my-package', '/workspace')
+   * // { source: 'local', resolvedName: 'my-package', localPath: '/workspace/plugins/my-package', version: '1.0.0' }
+   *
+   * // Not found locally, resolve to npm
+   * await resolveLocation('release', '/workspace')
+   * // { source: 'npm', resolvedName: 'release', npmPackage: '@launch77-shared/plugin-release' }
+   *
+   * // Scoped package always resolves to npm
+   * await resolveLocation('@ibm/analytics', '/workspace')
+   * // { source: 'npm', resolvedName: '@ibm/analytics', npmPackage: '@ibm/analytics' }
+   */
+  async resolveLocation(name, workspaceRoot) {
+    const trimmedName = name.trim();
+    const parsed = this.npmService.parsePackageName(trimmedName);
+    if (parsed.type === "scoped") {
+      return {
+        source: "npm",
+        resolvedName: trimmedName,
+        npmPackage: trimmedName
+      };
+    }
+    const localPath = path9.join(workspaceRoot, this.getFolderName(), trimmedName);
+    const localExists = await fs6.pathExists(localPath);
+    if (localExists) {
+      const isValid = await this.verify(localPath);
+      if (isValid) {
+        const version = await this.readVersion(localPath);
+        return {
+          source: "local",
+          resolvedName: trimmedName,
+          localPath,
+          version
+        };
+      }
+    }
+    const npmPackage = this.toNpmPackageName(trimmedName);
     return {
-      isValid: false,
-      error: "Plugin name can only contain lowercase letters (a-z), numbers (0-9), and hyphens (-)"
+      source: "npm",
+      resolvedName: trimmedName,
+      npmPackage
     };
   }
-  return { isValid: true };
+};
+
+// src/modules/plugin/resolvers/plugin-resolver.ts
+var PluginResolver = class extends PackageResolver {
+  getFolderName() {
+    return "plugins";
+  }
+  getPackagePrefix() {
+    return "@launch77-shared/plugin-";
+  }
+  async verify(localPath) {
+    const hasPluginJson = await fs7.pathExists(path10.join(localPath, "plugin.json"));
+    const hasGenerator = await fs7.pathExists(path10.join(localPath, "dist/generator.js"));
+    const hasPackageJson = await fs7.pathExists(path10.join(localPath, "package.json"));
+    if (!hasPluginJson || !hasGenerator || !hasPackageJson) {
+      return false;
+    }
+    try {
+      const packageJson = await fs7.readJson(path10.join(localPath, "package.json"));
+      return !!packageJson.version;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/modules/plugin/utils/plugin-utils.ts
+function mapLocationTypeToTarget(locationType) {
+  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:
+      throw createInvalidContextError(locationType);
+  }
 }
-function isValidNpmPackageName(name) {
-  if (!name || name.trim().length === 0) {
+
+// src/modules/plugin/services/plugin-service.ts
+var PluginService = class {
+  constructor() {
+    this.pluginResolver = new PluginResolver();
+    this.metadataService = new MetadataService();
+    this.npmService = new NpmService();
+  }
+  /**
+   * Validate a plugin name
+   */
+  validatePluginName(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+      return { isValid: false, errors: ["Plugin name cannot be empty"] };
+    }
+    if (trimmed.startsWith("@")) {
+      const parts = trimmed.split("/");
+      if (parts.length !== 2 || !parts[0].slice(1) || !parts[1]) {
+        return { isValid: false, errors: ["Scoped package must be in format @org/package"] };
+      }
+      const scope = parts[0].slice(1);
+      const packageName = parts[1];
+      if (!this.isValidPackageNamePart(scope)) {
+        return { isValid: false, errors: [`Invalid scope: ${scope}`] };
+      }
+      if (!this.isValidPackageNamePart(packageName)) {
+        return { isValid: false, errors: [`Invalid package name: ${packageName}`] };
+      }
+    } else {
+      if (!this.isValidPackageNamePart(trimmed)) {
+        return { isValid: false, errors: [`Invalid package name: ${trimmed}`] };
+      }
+    }
+    return { isValid: true };
+  }
+  /**
+   * Validate plugin metadata
+   */
+  validatePluginMetadata(metadata) {
+    const errors = [];
+    if (!metadata.targets || metadata.targets.length === 0) {
+      errors.push("Plugin must specify at least one target");
+    }
+    if (metadata.showcaseUrl) {
+      const showcaseValidation = this.validateShowcaseUrl(metadata.showcaseUrl);
+      if (!showcaseValidation.isValid) {
+        errors.push(showcaseValidation.errors?.[0] || "Invalid showcase URL");
+      }
+    }
     return {
-      isValid: false,
-      error: "Package name cannot be empty"
+      isValid: errors.length === 0,
+      errors: errors.length > 0 ? errors : void 0
     };
   }
-  const trimmedName = name.trim();
-  if (trimmedName.startsWith("@")) {
-    const scopedPattern = /^@([a-z0-9-]+)\/([a-z0-9-]+)$/;
-    if (!scopedPattern.test(trimmedName)) {
+  /**
+   * Validate a showcase URL
+   * Note: This is primarily used by the webapp template
+   */
+  validateShowcaseUrl(url) {
+    if (!url) {
+      return { isValid: true };
+    }
+    if (!url.startsWith("/")) {
       return {
         isValid: false,
-        error: "Scoped package must be in format @org/package where org and package contain only lowercase letters, numbers, and hyphens"
+        errors: ["Showcase URL must be a relative path starting with /"]
+      };
+    }
+    if (url.includes("://") || url.startsWith("//")) {
+      return {
+        isValid: false,
+        errors: ["Showcase URL cannot be an external URL"]
+      };
+    }
+    try {
+      new URL(url, "http://example.com");
+      return { isValid: true };
+    } catch {
+      return {
+        isValid: false,
+        errors: ["Invalid URL format"]
       };
     }
-    return { isValid: true };
   }
-  if (!/^[a-z][a-z0-9-]*$/.test(trimmedName)) {
+  /**
+   * Validate plugin consistency between plugin.json and package.json
+   */
+  async validatePluginConsistency(pluginPath) {
+    const errors = [];
+    try {
+      const packageJsonPath = path11.join(pluginPath, "package.json");
+      const pluginJsonPath = path11.join(pluginPath, "plugin.json");
+      if (!await fsExtra.pathExists(packageJsonPath)) {
+        errors.push("package.json not found");
+        return { isValid: false, errors };
+      }
+      if (!await fsExtra.pathExists(pluginJsonPath)) {
+        errors.push("plugin.json not found");
+        return { isValid: false, errors };
+      }
+      const packageJson = await fsExtra.readJSON(packageJsonPath);
+      const pluginJson = await fsExtra.readJSON(pluginJsonPath);
+      if (pluginJson.dependencies) {
+        const packageDeps = packageJson.dependencies || {};
+        const packageDevDeps = packageJson.devDependencies || {};
+        for (const [dep, version] of Object.entries(pluginJson.dependencies)) {
+          if (!packageDeps[dep] && !packageDevDeps[dep]) {
+            errors.push(`Dependency '${dep}' specified in plugin.json but not in package.json`);
+          } else {
+            const packageVersion = packageDeps[dep] || packageDevDeps[dep];
+            if (packageVersion !== version) {
+              errors.push(`Dependency '${dep}' version mismatch: plugin.json has '${version}', package.json has '${packageVersion}'`);
+            }
+          }
+        }
+      }
+      if (pluginJson.devDependencies) {
+        const packageDevDeps = packageJson.devDependencies || {};
+        for (const [dep, version] of Object.entries(pluginJson.devDependencies)) {
+          if (!packageDevDeps[dep]) {
+            errors.push(`Dev dependency '${dep}' specified in plugin.json but not in package.json`);
+          } else if (packageDevDeps[dep] !== version) {
+            errors.push(`Dev dependency '${dep}' version mismatch: plugin.json has '${version}', package.json has '${packageDevDeps[dep]}'`);
+          }
+        }
+      }
+    } catch (error) {
+      errors.push(`Failed to validate plugin consistency: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
     return {
-      isValid: false,
-      error: "Package name must start with a lowercase letter and contain only lowercase letters (a-z), numbers (0-9), and hyphens (-)"
+      isValid: errors.length === 0,
+      errors: errors.length > 0 ? errors : void 0
     };
   }
-  return { isValid: true };
-}
-function parsePluginName(name) {
-  if (!name || name.trim().length === 0) {
+  /**
+   * Check if a package name part is valid
+   */
+  isValidPackageNamePart(part) {
+    const validPattern = /^[a-z][a-z0-9._-]*$/;
+    return validPattern.test(part);
+  }
+  /**
+   * Validate plugin name, resolve its location, and download if needed
+   */
+  async validateAndResolvePlugin(pluginName, workspaceRoot, logger) {
+    logger(chalk2.blue(`
+\u{1F50D} Resolving plugin "${pluginName}"...`));
+    logger(`  \u251C\u2500 Validating plugin name...`);
+    const validation = this.pluginResolver.validateInput(pluginName);
+    if (!validation.isValid) {
+      throw new PluginResolutionError(pluginName, validation.error || "Invalid plugin name");
+    }
+    logger(`  \u2502  \u2514\u2500 ${chalk2.green("\u2713")} Valid plugin name`);
+    logger(`  \u251C\u2500 Checking local workspace: ${chalk2.dim(`plugins/${pluginName}`)}`);
+    const resolution = await this.pluginResolver.resolveLocation(pluginName, workspaceRoot);
+    let pluginPath;
+    let version;
+    if (resolution.source === "local") {
+      logger(`  \u2502  \u2514\u2500 ${chalk2.green("\u2713")} Found local plugin`);
+      pluginPath = resolution.localPath;
+      version = resolution.version;
+    } else {
+      logger(`  \u2502  \u2514\u2500 ${chalk2.dim("Not found locally")}`);
+      logger(`  \u251C\u2500 Resolving to npm package: ${chalk2.cyan(resolution.npmPackage)}`);
+      pluginPath = await this.downloadNpmPlugin(resolution.npmPackage, workspaceRoot, logger);
+      const packageJsonPath = path11.join(pluginPath, "package.json");
+      const packageJsonContent = await fs8.readFile(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(packageJsonContent);
+      version = packageJson.version;
+    }
+    logger(`  \u2514\u2500 ${chalk2.green("\u2713")} Plugin resolved
+`);
     return {
-      type: "invalid",
-      isValid: false,
-      error: "Plugin name cannot be empty"
+      pluginPath,
+      source: resolution.source,
+      npmPackage: resolution.npmPackage,
+      version
     };
   }
-  const trimmedName = name.trim();
-  if (trimmedName.startsWith("@")) {
-    const validation2 = isValidNpmPackageName(trimmedName);
-    if (!validation2.isValid) {
-      return {
-        type: "invalid",
-        isValid: false,
-        error: validation2.error
-      };
+  /**
+   * Read plugin metadata and validate it supports the current target
+   */
+  async validatePluginTargets(pluginPath, pluginName, currentTarget) {
+    const metadata = await this.metadataService.readPluginMetadata(pluginPath);
+    if (!metadata.targets || metadata.targets.length === 0) {
+      throw new MissingPluginTargetsError(pluginName);
     }
-    const match = trimmedName.match(/^@([a-z0-9-]+)\/([a-z0-9-]+)$/);
-    if (match) {
+    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
+   */
+  async checkExistingInstallation(pluginName, packagePath, logger) {
+    const existingInstallation = await this.isPluginInstalled(pluginName, packagePath);
+    if (existingInstallation) {
+      logger(chalk2.yellow(`
+\u2139\uFE0F  Plugin '${pluginName}' is already installed in this package.
+`));
+      logger(`Package: ${chalk2.cyan(existingInstallation.package)} (${existingInstallation.source})`);
+      logger(`Version: ${existingInstallation.version}`);
+      logger(`Installed: ${existingInstallation.installedAt}
+`);
+      logger(chalk2.gray("To reinstall: Remove from package.json launch77.installedPlugins"));
+      logger(chalk2.gray("(plugin:remove command coming soon)\n"));
       return {
-        type: "scoped",
-        isValid: true,
-        name: trimmedName,
-        org: match[1],
-        package: match[2]
+        pluginName,
+        filesInstalled: false,
+        packageJsonUpdated: false,
+        dependenciesInstalled: false
       };
     }
+    return null;
+  }
+  /**
+   * Install a plugin to the current package
+   */
+  async installPlugin(request, context, logger = console.log) {
+    const { pluginName } = request;
+    const currentTarget = mapLocationTypeToTarget(context.locationType);
+    const { pluginPath, source, npmPackage, version } = await this.validateAndResolvePlugin(pluginName, context.workspaceRoot, logger);
+    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 {
-      type: "invalid",
-      isValid: false,
-      error: "Invalid scoped package format"
+      pluginName,
+      filesInstalled: true,
+      packageJsonUpdated: true,
+      dependenciesInstalled: true
     };
   }
-  const validation = validatePluginName(trimmedName);
-  if (!validation.isValid) {
+  /**
+   * Download and install an npm plugin package
+   */
+  async downloadNpmPlugin(npmPackage, workspaceRoot, logger) {
+    logger(`  \u2514\u2500 Installing from npm: ${chalk2.cyan(npmPackage)}...`);
+    const result = await downloadNpmPackage({
+      packageName: npmPackage,
+      workspaceRoot
+    });
+    return result.packagePath;
+  }
+  getPackagePath(context) {
+    switch (context.locationType) {
+      case "workspace-app":
+        return path11.join(context.appsDir, context.appName);
+      case "workspace-library":
+        return path11.join(context.workspaceRoot, "libraries", context.appName);
+      case "workspace-plugin":
+        return path11.join(context.workspaceRoot, "plugins", context.appName);
+      case "workspace-app-template":
+        return path11.join(context.workspaceRoot, "app-templates", context.appName);
+      default:
+        throw new InvalidPluginContextError(`Cannot install plugin from ${context.locationType}`);
+    }
+  }
+  async runGenerator(pluginPath, appPath, context) {
+    try {
+      const generatorPath = path11.join(pluginPath, "dist/generator.js");
+      const args = [generatorPath, `--appPath=${appPath}`, `--appName=${context.appName}`, `--workspaceName=${context.workspaceName}`, `--pluginPath=${pluginPath}`];
+      await execa4("node", args, {
+        cwd: pluginPath,
+        stdio: "inherit"
+      });
+    } catch (error) {
+      throw new PluginInstallationError(`Generator failed: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : void 0);
+    }
+  }
+  async isPluginInstalled(pluginName, packagePath) {
+    try {
+      const packageJsonPath = path11.join(packagePath, "package.json");
+      const packageJsonContent = await fs8.readFile(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(packageJsonContent);
+      const manifest = packageJson.launch77;
+      if (manifest?.installedPlugins?.[pluginName]) {
+        return manifest.installedPlugins[pluginName];
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Write plugin installation metadata to the target package's package.json
+   */
+  async writePluginManifest(packagePath, installationInfo) {
+    try {
+      const packageJsonPath = path11.join(packagePath, "package.json");
+      const packageJsonContent = await fs8.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;
+      manifest.installedPlugins[installationInfo.pluginName] = {
+        package: installationInfo.packageName,
+        version: installationInfo.version,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        source: installationInfo.source
+      };
+      await fs8.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 : void 0);
+    }
+  }
+  /**
+   * Delete a plugin from the workspace
+   */
+  async deletePlugin(request, context) {
+    const { pluginName } = request;
+    const nameValidation = this.validatePluginName(pluginName);
+    if (!nameValidation.isValid) {
+      throw new InvalidPluginNameError(nameValidation.errors?.[0] || "Invalid plugin name");
+    }
+    if (context.locationType === "unknown") {
+      throw new Error("Must be run from within a Launch77 workspace. Create a workspace first: launch77 init my-workspace");
+    }
+    const pluginPath = path11.join(context.workspaceRoot, "plugins", pluginName);
+    if (!await fsExtra.pathExists(pluginPath)) {
+      throw new PluginDirectoryNotFoundError(pluginName, pluginPath);
+    }
+    await fsExtra.remove(pluginPath);
+    await this.npmService.install(context.workspaceRoot);
     return {
-      type: "invalid",
-      isValid: false,
-      error: validation.error
+      pluginName
     };
   }
-  return {
-    type: "unscoped",
-    isValid: true,
-    name: trimmedName
-  };
-}
+};
 
-// src/utils/validate-plugin-consistency.ts
-import * as fs5 from "fs/promises";
-import * as path7 from "path";
-import chalk2 from "chalk";
-async function validatePluginConsistency(pluginPath) {
-  const packageJsonPath = path7.join(pluginPath, "package.json");
-  const packageJsonContent = await fs5.readFile(packageJsonPath, "utf-8");
-  const packageJson = JSON.parse(packageJsonContent);
-  const pluginJsonPath = path7.join(pluginPath, "plugin.json");
-  const pluginJsonContent = await fs5.readFile(pluginJsonPath, "utf-8");
-  const pluginJson = JSON.parse(pluginJsonContent);
-  const errors = [];
-  if (pluginJson.libraryDependencies) {
-    for (const [library, pluginJsonVersion] of Object.entries(pluginJson.libraryDependencies)) {
-      const packageJsonVersion = packageJson.dependencies?.[library];
-      if (!packageJsonVersion) {
-        errors.push({
-          library,
-          packageJsonVersion: "MISSING",
-          pluginJsonVersion
-        });
-      } else if (packageJsonVersion !== pluginJsonVersion) {
-        errors.push({
-          library,
-          packageJsonVersion,
-          pluginJsonVersion
-        });
-      }
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-async function validatePluginConsistencyOrThrow(pluginPath) {
-  const result = await validatePluginConsistency(pluginPath);
-  if (!result.valid) {
-    const packageJsonPath = path7.join(pluginPath, "package.json");
-    const packageJsonContent = await fs5.readFile(packageJsonPath, "utf-8");
-    const packageJson = JSON.parse(packageJsonContent);
-    const pluginName = packageJson.name || "unknown";
-    console.error(chalk2.red("\n\u274C Plugin consistency validation failed!\n"));
-    console.error(chalk2.yellow(`Plugin: ${pluginName}
-`));
-    console.error(chalk2.white("Library versions in package.json must match plugin.json:\n"));
-    for (const error of result.errors) {
-      console.error(chalk2.white(`  ${error.library}:`));
-      if (error.packageJsonVersion === "MISSING") {
-        console.error(chalk2.red(`    \u2717 package.json: MISSING (library not in dependencies)`));
-        console.error(chalk2.red(`    \u2717 plugin.json:  ${error.pluginJsonVersion}`));
-      } else {
-        console.error(chalk2.red(`    \u2717 package.json: ${error.packageJsonVersion}`));
-        console.error(chalk2.red(`    \u2717 plugin.json:  ${error.pluginJsonVersion}`));
-      }
-      console.error();
-    }
-    console.error(chalk2.white("Why this matters:"));
-    console.error(chalk2.white("  - Plugin templates use package.json versions during development"));
-    console.error(chalk2.white("  - End users get plugin.json versions when they install the plugin"));
-    console.error(chalk2.white("  - Mismatched versions cause template code to break for users\n"));
-    console.error(chalk2.cyan("Fix: Update both files to use the same version.\n"));
-    throw new Error("Plugin validation failed - library versions do not match");
+// src/modules/plugin/services/plugin-installer.ts
+import * as path12 from "path";
+import { execa as execa5 } from "execa";
+var PluginInstaller = class {
+  constructor(filesystemService) {
+    this.filesystemService = filesystemService || new FilesystemService();
   }
-}
+  /**
+   * Install a plugin into the target location
+   */
+  async install(plugin, target, targetPath, context, logger) {
+    await this.runGenerator(plugin, target, targetPath, context, logger);
+    await this.trackInstallation(plugin, targetPath);
+  }
+  /**
+   * Run a plugin's generator
+   */
+  async runGenerator(plugin, _target, targetPath, launch77Context, logger) {
+    const generatorPath = path12.join(plugin.path, "dist", "generator.js");
+    if (!await this.filesystemService.pathExists(generatorPath)) {
+      throw new Error(`Plugin generator not found at: ${generatorPath}`);
+    }
+    logger?.("Running plugin generator...");
+    try {
+      const generatorModule = await import(generatorPath);
+      const GeneratorClass = generatorModule.default || generatorModule.Generator;
+      if (!GeneratorClass) {
+        throw new Error("Plugin generator does not export a valid Generator class");
+      }
+      const context = {
+        appPath: targetPath,
+        appName: launch77Context.appName || "",
+        workspaceName: launch77Context.workspaceName || "",
+        pluginPath: plugin.path
+      };
+      const generator = new GeneratorClass(context);
+      if (typeof generator.run !== "function") {
+        throw new Error("Plugin generator does not have a run() method");
+      }
+      await generator.run();
+    } catch (error) {
+      throw new Error(`Failed to run plugin generator: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Track plugin installation in package.json
+   */
+  async trackInstallation(plugin, targetPath) {
+    const packageJsonPath = path12.join(targetPath, "package.json");
+    if (!await this.filesystemService.pathExists(packageJsonPath)) {
+      throw new Error(`package.json not found at: ${packageJsonPath}`);
+    }
+    const packageJson = await this.filesystemService.readJSON(packageJsonPath);
+    if (!packageJson.launch77) {
+      packageJson.launch77 = {};
+    }
+    if (!packageJson.launch77.installedPlugins) {
+      packageJson.launch77.installedPlugins = {};
+    }
+    const installationRecord = {
+      package: plugin.name,
+      version: plugin.version,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      source: plugin.source
+    };
+    const pluginKey = this.extractPluginKey(plugin.name);
+    packageJson.launch77.installedPlugins[pluginKey] = installationRecord;
+    await this.filesystemService.writeJSON(packageJsonPath, packageJson);
+  }
+  /**
+   * Check if a plugin is already installed
+   */
+  async isInstalled(pluginName, targetPath) {
+    const packageJsonPath = path12.join(targetPath, "package.json");
+    if (!await this.filesystemService.pathExists(packageJsonPath)) {
+      return false;
+    }
+    const packageJson = await this.filesystemService.readJSON(packageJsonPath);
+    const pluginKey = this.extractPluginKey(pluginName);
+    return !!packageJson.launch77?.installedPlugins?.[pluginKey];
+  }
+  /**
+   * Get installed plugin metadata
+   */
+  async getInstalledPlugin(pluginName, targetPath) {
+    const packageJsonPath = path12.join(targetPath, "package.json");
+    if (!await this.filesystemService.pathExists(packageJsonPath)) {
+      return null;
+    }
+    const packageJson = await this.filesystemService.readJSON(packageJsonPath);
+    const pluginKey = this.extractPluginKey(pluginName);
+    return packageJson.launch77?.installedPlugins?.[pluginKey] || null;
+  }
+  /**
+   * Uninstall a plugin
+   */
+  async uninstall(pluginName, targetPath) {
+    const packageJsonPath = path12.join(targetPath, "package.json");
+    if (!await this.filesystemService.pathExists(packageJsonPath)) {
+      throw new Error(`package.json not found at: ${packageJsonPath}`);
+    }
+    const packageJson = await this.filesystemService.readJSON(packageJsonPath);
+    const pluginKey = this.extractPluginKey(pluginName);
+    if (!packageJson.launch77?.installedPlugins?.[pluginKey]) {
+      throw new Error(`Plugin '${pluginName}' is not installed`);
+    }
+    delete packageJson.launch77.installedPlugins[pluginKey];
+    if (Object.keys(packageJson.launch77.installedPlugins).length === 0) {
+      delete packageJson.launch77.installedPlugins;
+    }
+    if (Object.keys(packageJson.launch77).length === 0) {
+      delete packageJson.launch77;
+    }
+    await this.filesystemService.writeJSON(packageJsonPath, packageJson);
+  }
+  /**
+   * Install npm dependencies
+   */
+  async installDependencies(targetPath) {
+    try {
+      await execa5("npm", ["install"], { cwd: targetPath });
+    } catch (error) {
+      try {
+        await execa5("npm", ["install", "--legacy-peer-deps"], { cwd: targetPath });
+      } catch (retryError) {
+        throw new Error(`Failed to install dependencies: ${retryError instanceof Error ? retryError.message : "Unknown error"}`);
+      }
+    }
+  }
+  /**
+   * Extract plugin key from package name
+   */
+  extractPluginKey(packageName) {
+    let key = packageName;
+    if (key.startsWith("@")) {
+      const parts = key.split("/");
+      key = parts[1] || key;
+    }
+    if (key.startsWith("plugin-")) {
+      key = key.substring("plugin-".length);
+    }
+    return key;
+  }
+};
+
+// src/modules/package-manifest/services/package-manifest-service.ts
+import * as path13 from "path";
+var PackageManifestService = class {
+  constructor(filesystemService) {
+    this.filesystemService = filesystemService || new FilesystemService();
+  }
+  /**
+   * Read the launch77 section (package manifest) from a package.json
+   */
+  async readPackageManifest(packagePath) {
+    const packageJsonPath = path13.join(packagePath, "package.json");
+    if (!await this.filesystemService.pathExists(packageJsonPath)) {
+      return null;
+    }
+    try {
+      const packageJson = await this.filesystemService.readJSON(packageJsonPath);
+      return packageJson.launch77 || null;
+    } catch (error) {
+      throw new Error(`Failed to read package manifest from ${packageJsonPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Write the launch77 section (package manifest) to a package.json
+   */
+  async writePackageManifest(packagePath, manifest) {
+    const packageJsonPath = path13.join(packagePath, "package.json");
+    if (!await this.filesystemService.pathExists(packageJsonPath)) {
+      throw new Error(`package.json not found at: ${packageJsonPath}`);
+    }
+    try {
+      const packageJson = await this.filesystemService.readJSON(packageJsonPath);
+      packageJson.launch77 = manifest;
+      await this.filesystemService.writeJSON(packageJsonPath, packageJson);
+    } catch (error) {
+      throw new Error(`Failed to write package manifest to ${packageJsonPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Add an installed plugin to the manifest
+   */
+  async addInstalledPlugin(packagePath, pluginKey, metadata) {
+    const packageJsonPath = path13.join(packagePath, "package.json");
+    if (!await this.filesystemService.pathExists(packageJsonPath)) {
+      throw new Error(`package.json not found at: ${packageJsonPath}`);
+    }
+    try {
+      const packageJson = await this.filesystemService.readJSON(packageJsonPath);
+      if (!packageJson.launch77) {
+        packageJson.launch77 = {};
+      }
+      if (!packageJson.launch77.installedPlugins) {
+        packageJson.launch77.installedPlugins = {};
+      }
+      packageJson.launch77.installedPlugins[pluginKey] = metadata;
+      await this.filesystemService.writeJSON(packageJsonPath, packageJson);
+    } catch (error) {
+      throw new Error(`Failed to add plugin to package manifest: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Remove an installed plugin from the manifest
+   */
+  async removeInstalledPlugin(packagePath, pluginKey) {
+    const packageJsonPath = path13.join(packagePath, "package.json");
+    if (!await this.filesystemService.pathExists(packageJsonPath)) {
+      throw new Error(`package.json not found at: ${packageJsonPath}`);
+    }
+    try {
+      const packageJson = await this.filesystemService.readJSON(packageJsonPath);
+      if (!packageJson.launch77?.installedPlugins?.[pluginKey]) {
+        throw new Error(`Plugin '${pluginKey}' is not installed`);
+      }
+      delete packageJson.launch77.installedPlugins[pluginKey];
+      if (Object.keys(packageJson.launch77.installedPlugins).length === 0) {
+        delete packageJson.launch77.installedPlugins;
+      }
+      if (Object.keys(packageJson.launch77).length === 0) {
+        delete packageJson.launch77;
+      }
+      await this.filesystemService.writeJSON(packageJsonPath, packageJson);
+    } catch (error) {
+      throw new Error(`Failed to remove plugin from package manifest: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Get installed plugins from the manifest
+   */
+  async getInstalledPlugins(packagePath) {
+    const manifest = await this.readPackageManifest(packagePath);
+    return manifest?.installedPlugins || {};
+  }
+  /**
+   * Check if a plugin is installed
+   */
+  async isPluginInstalled(packagePath, pluginKey) {
+    const installedPlugins = await this.getInstalledPlugins(packagePath);
+    return !!installedPlugins[pluginKey];
+  }
+  /**
+   * Get a specific installed plugin metadata
+   */
+  async getInstalledPlugin(packagePath, pluginKey) {
+    const installedPlugins = await this.getInstalledPlugins(packagePath);
+    return installedPlugins[pluginKey] || null;
+  }
+  /**
+   * Update package.json dependencies
+   */
+  async addDependency(packagePath, packageName, version, isDev = false) {
+    const packageJsonPath = path13.join(packagePath, "package.json");
+    if (!await this.filesystemService.pathExists(packageJsonPath)) {
+      throw new Error(`package.json not found at: ${packageJsonPath}`);
+    }
+    try {
+      const packageJson = await this.filesystemService.readJSON(packageJsonPath);
+      const depsKey = isDev ? "devDependencies" : "dependencies";
+      if (!packageJson[depsKey]) {
+        packageJson[depsKey] = {};
+      }
+      packageJson[depsKey][packageName] = version;
+      await this.filesystemService.writeJSON(packageJsonPath, packageJson);
+    } catch (error) {
+      throw new Error(`Failed to add dependency: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Remove a dependency from package.json
+   */
+  async removeDependency(packagePath, packageName) {
+    const packageJsonPath = path13.join(packagePath, "package.json");
+    if (!await this.filesystemService.pathExists(packageJsonPath)) {
+      throw new Error(`package.json not found at: ${packageJsonPath}`);
+    }
+    try {
+      const packageJson = await this.filesystemService.readJSON(packageJsonPath);
+      if (packageJson.dependencies?.[packageName]) {
+        delete packageJson.dependencies[packageName];
+        if (Object.keys(packageJson.dependencies).length === 0) {
+          delete packageJson.dependencies;
+        }
+      }
+      if (packageJson.devDependencies?.[packageName]) {
+        delete packageJson.devDependencies[packageName];
+        if (Object.keys(packageJson.devDependencies).length === 0) {
+          delete packageJson.devDependencies;
+        }
+      }
+      await this.filesystemService.writeJSON(packageJsonPath, packageJson);
+    } catch (error) {
+      throw new Error(`Failed to remove dependency: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Get the package.json content
+   */
+  async readPackageJson(packagePath) {
+    const packageJsonPath = path13.join(packagePath, "package.json");
+    return await this.filesystemService.readJSON(packageJsonPath);
+  }
+  /**
+   * Write the package.json content
+   */
+  async writePackageJson(packagePath, packageJson) {
+    const packageJsonPath = path13.join(packagePath, "package.json");
+    await this.filesystemService.writeJSON(packageJsonPath, packageJson);
+  }
+};
 export {
+  FilesystemService,
   Generator,
+  InvalidPluginContextError,
+  InvalidPluginNameError,
+  MetadataService,
+  MissingPluginTargetsError,
+  NpmInstallationError,
+  NpmService,
+  PackageManifestService,
+  PackageResolver,
+  PluginDirectoryNotFoundError,
+  PluginInstallationError,
+  PluginInstaller,
+  PluginNotFoundError,
+  PluginResolutionError,
+  PluginResolver,
+  PluginService,
   StandardGenerator,
-  copyRecursive,
+  WorkspaceManifestService,
+  WorkspaceService,
+  createInvalidContextError,
+  createInvalidTargetError,
   detectLaunch77Context,
-  isValidNpmPackageName,
-  parsePluginName,
-  pathExists,
-  readPluginMetadata,
-  readTemplateMetadata,
-  validatePluginConsistency,
-  validatePluginConsistencyOrThrow,
-  validatePluginName
+  downloadNpmPackage,
+  parseLocationFromPath
 };
 //# sourceMappingURL=index.js.map