wave-agent-sdk 0.14.0 → 0.14.1

package/dist/services/MarketplaceService.js

@@ -3,14 +3,20 @@ import * as path from "path";
 import * as crypto from "crypto";
 import { getPluginsDir } from "../utils/configPaths.js";
 import { GitService } from "./GitService.js";
+import { ConfigurationService } from "./configurationService.js";
 /**
  * Marketplace Service
  *
  * Handles local plugin marketplace registration, plugin installation,
  * and state management for installed plugins.
+ *
+ * Marketplace declarations are now scoped (user/project/local) via settings files.
+ * known_marketplaces.json is kept as a cache for installLocation/lastUpdated metadata.
  */
 export class MarketplaceService {
-    constructor() {
+    constructor(workdir = process.cwd(), configurationService = new ConfigurationService()) {
+        this.workdir = workdir;
+        this.configurationService = configurationService;
         this.pluginsDir = getPluginsDir();
         this.knownMarketplacesPath = path.join(this.pluginsDir, "known_marketplaces.json");
         this.installedPluginsPath = path.join(this.pluginsDir, "installed_plugins.json");
@@ -20,6 +26,7 @@ export class MarketplaceService {
         this.marketplacesDir = path.join(this.pluginsDir, "marketplaces");
         this.gitService = new GitService();
         this.ensureDirectoryStructure();
+        this.runMigration();
     }
     /**
      * Ensures the required directory structure exists in ~/.wave/plugins
@@ -31,6 +38,32 @@ export class MarketplaceService {
             }
         });
     }
+    /**
+     * Backwards compatibility migration: migrate entries from known_marketplaces.json
+     * to user-level settings if they aren't already declared there.
+     */
+    async runMigration() {
+        try {
+            const cacheRegistry = await this.getCacheRegistry();
+            const scopedMarketplaces = this.configurationService.getMergedMarketplaces(this.workdir);
+            const userMarketplaces = this.configurationService.getScopedMarketplaces(this.workdir, "user");
+            const entriesToMigrate = (cacheRegistry?.marketplaces ?? []).filter((m) => !scopedMarketplaces[m.name] && !userMarketplaces[m.name]);
+            if (entriesToMigrate.length > 0) {
+                for (const m of entriesToMigrate) {
+                    if (m.name === MarketplaceService.BUILTIN_MARKETPLACE.name)
+                        continue;
+                    const config = {
+                        source: m.source,
+                        autoUpdate: m.autoUpdate,
+                    };
+                    await this.configurationService.addMarketplaceToScope(this.workdir, "user", m.name, config);
+                }
+            }
+        }
+        catch {
+            // Migration failure should not block startup
+        }
+    }
     /**
      * Check if a lock file is stale by reading its PID and checking if the process is alive.
      * Returns true if the lock is stale and safe to remove.
@@ -41,17 +74,16 @@ export class MarketplaceService {
             const pid = parseInt(content.trim(), 10);
             if (isNaN(pid))
                 return true;
-            // Check if the process is still running
             try {
                 process.kill(pid, 0);
-                return false; // Process exists, lock is valid
+                return false;
             }
             catch {
-                return true; // Process doesn't exist, lock is stale
+                return true;
             }
         }
         catch {
-            return true; // Can't read lock file, assume stale
+            return true;
         }
     }
     /**
@@ -63,7 +95,7 @@ export class MarketplaceService {
             return await fn();
         }
         let lockFd;
-        const maxRetries = 600; // 60 seconds total
+        const maxRetries = 600;
         const retryDelay = 100;
         for (let i = 0; i < maxRetries; i++) {
             try {
@@ -75,7 +107,6 @@ export class MarketplaceService {
                     typeof error === "object" &&
                     "code" in error &&
                     error.code === "EEXIST") {
-                    // Check for stale lock every 60 retries (every ~6 seconds)
                     if (i > 0 && i % 60 === 0) {
                         const stale = await this.isStaleLock();
                         if (stale) {
@@ -92,7 +123,6 @@ export class MarketplaceService {
         if (!lockFd) {
             throw new Error(`Failed to acquire marketplace lock after ${maxRetries} retries. If no other wave-agent process is running, please delete ${this.lockPath}`);
         }
-        // Write PID into the lock file for stale lock detection
         await fs.writeFile(this.lockPath, String(process.pid), "utf-8");
         MarketplaceService.isLockedInProcess = true;
         try {
@@ -105,37 +135,86 @@ export class MarketplaceService {
         }
     }
     /**
-     * Loads the known marketplaces registry
+     * Loads the cache registry from known_marketplaces.json
+     * Returns null if the file doesn't exist or has no parseable content (for first-run detection).
      */
-    async getKnownMarketplaces() {
+    async getCacheRegistry() {
         if (!existsSync(this.knownMarketplacesPath)) {
+            return null;
+        }
+        try {
+            const content = await fs.readFile(this.knownMarketplacesPath, "utf-8");
+            if (!content.trim()) {
+                return null;
+            }
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Legacy method: loads known marketplaces with builtin injection.
+     * @deprecated Use listMarketplaces() instead, which combines scoped settings.
+     */
+    async getKnownMarketplaces() {
+        const cache = await this.getCacheRegistry();
+        // If cache is null (file doesn't exist or has no parseable content), inject builtin
+        if (cache === null) {
             return {
                 marketplaces: [
                     {
                         ...MarketplaceService.BUILTIN_MARKETPLACE,
                         isBuiltin: true,
+                        declaredScope: "builtin",
                     },
                 ],
             };
         }
-        try {
-            const content = await fs.readFile(this.knownMarketplacesPath, "utf-8");
-            if (!content.trim()) {
-                return {
-                    marketplaces: [
-                        {
-                            ...MarketplaceService.BUILTIN_MARKETPLACE,
-                            isBuiltin: true,
-                        },
-                    ],
-                };
-            }
-            return JSON.parse(content);
+        // File has valid JSON - respect user's explicit choice even if empty
+        const hasBuiltin = cache.marketplaces.some((m) => m.name === MarketplaceService.BUILTIN_MARKETPLACE.name);
+        return {
+            marketplaces: cache.marketplaces.map((m) => ({
+                ...m,
+                isBuiltin: m.isBuiltin || m.name === MarketplaceService.BUILTIN_MARKETPLACE.name,
+                declaredScope: m.declaredScope ?? (hasBuiltin ? "builtin" : "user"),
+            })),
+        };
+    }
+    /**
+     * Updates the cache registry with metadata for a marketplace
+     */
+    async updateCacheMarketplace(name, metadata) {
+        const registry = await this.getCacheRegistry();
+        const marketplaces = registry?.marketplaces ?? [];
+        const existingIndex = marketplaces.findIndex((m) => m.name === name);
+        if (existingIndex >= 0) {
+            marketplaces[existingIndex] = {
+                ...marketplaces[existingIndex],
+                ...metadata,
+            };
         }
-        catch (error) {
-            console.error("Failed to load known marketplaces:", error);
-            return { marketplaces: [] };
+        else {
+            marketplaces.push({
+                name,
+                source: metadata.source || { source: "directory", path: "" },
+                ...metadata,
+            });
         }
+        const tmpPath = `${this.knownMarketplacesPath}.tmp`;
+        await fs.writeFile(tmpPath, JSON.stringify({ marketplaces }, null, 2));
+        await fs.rename(tmpPath, this.knownMarketplacesPath);
+    }
+    /**
+     * Removes a marketplace from the cache registry
+     */
+    async removeFromCache(name) {
+        const registry = await this.getCacheRegistry();
+        const marketplaces = registry?.marketplaces ?? [];
+        const filtered = marketplaces.filter((m) => m.name !== name);
+        const tmpPath = `${this.knownMarketplacesPath}.tmp`;
+        await fs.writeFile(tmpPath, JSON.stringify({ marketplaces: filtered }, null, 2));
+        await fs.rename(tmpPath, this.knownMarketplacesPath);
     }
     /**
      * Loads the installed plugins registry
@@ -156,14 +235,6 @@ export class MarketplaceService {
             return { plugins: [] };
         }
     }
-    /**
-     * Saves the known marketplaces registry
-     */
-    async saveKnownMarketplaces(registry) {
-        const tmpPath = `${this.knownMarketplacesPath}.tmp`;
-        await fs.writeFile(tmpPath, JSON.stringify(registry, null, 2));
-        await fs.rename(tmpPath, this.knownMarketplacesPath);
-    }
     /**
      * Saves the installed plugins registry
      */
@@ -172,17 +243,32 @@ export class MarketplaceService {
         await fs.writeFile(tmpPath, JSON.stringify(registry, null, 2));
         await fs.rename(tmpPath, this.installedPluginsPath);
     }
+    /**
+     * Finds the first existing marketplace manifest path.
+     * Prefers .wave-plugin/ for backward compatibility, falls back to .claude-plugin/.
+     * Returns null if neither exists.
+     */
+    async findMarketplaceManifestPath(dir) {
+        const waveManifestPath = path.join(dir, ".wave-plugin", "marketplace.json");
+        const claudeManifestPath = path.join(dir, ".claude-plugin", "marketplace.json");
+        if (existsSync(waveManifestPath)) {
+            return waveManifestPath;
+        }
+        if (existsSync(claudeManifestPath)) {
+            return claudeManifestPath;
+        }
+        return null;
+    }
     /**
      * Loads a marketplace manifest from a local path
      */
     async loadMarketplaceManifest(marketplacePath) {
-        const manifestPath = path.join(marketplacePath, ".wave-plugin", "marketplace.json");
-        if (!existsSync(manifestPath)) {
-            throw new Error(`Marketplace manifest not found at ${manifestPath}`);
+        const manifestPath = await this.findMarketplaceManifestPath(marketplacePath);
+        if (!manifestPath) {
+            throw new Error(`Marketplace manifest not found at ${marketplacePath}. Neither .wave-plugin/marketplace.json nor .claude-plugin/marketplace.json exists.`);
         }
         const content = await fs.readFile(manifestPath, "utf-8");
         const manifest = JSON.parse(content);
-        // Basic validation
         if (!manifest.name ||
             !manifest.plugins ||
             !Array.isArray(manifest.plugins)) {
@@ -193,26 +279,49 @@ export class MarketplaceService {
     /**
      * Resolves the local path for a marketplace
      */
-    getMarketplacePath(marketplace) {
-        if (marketplace.source.source === "directory") {
-            return marketplace.source.path;
+    getMarketplacePath(source) {
+        if (source.source === "directory") {
+            return source.path;
         }
-        else if (marketplace.source.source === "github") {
-            return path.join(this.marketplacesDir, marketplace.source.repo);
+        else if (source.source === "github") {
+            return path.join(this.marketplacesDir, source.repo);
         }
         else {
-            // For general git, use a hash of the URL to avoid path issues
-            const hash = crypto
-                .createHash("md5")
-                .update(marketplace.source.url)
-                .digest("hex");
+            const hash = crypto.createHash("md5").update(source.url).digest("hex");
             return path.join(this.marketplacesDir, hash);
         }
     }
+    /**
+     * Builds a KnownMarketplace from a scoped config, enriched with cache metadata
+     */
+    async buildMarketplaceEntry(name, config, cache, declaredScope) {
+        return {
+            name,
+            source: config.source,
+            autoUpdate: config.autoUpdate ?? cache?.autoUpdate,
+            lastUpdated: cache?.lastUpdated,
+            isBuiltin: name === MarketplaceService.BUILTIN_MARKETPLACE.name,
+            declaredScope,
+        };
+    }
+    /**
+     * Finds which scope declared a marketplace (user, project, local, or builtin)
+     */
+    getMarketplaceDeclaringSource(name) {
+        if (name === MarketplaceService.BUILTIN_MARKETPLACE.name)
+            return "builtin";
+        const scopes = ["local", "project", "user"];
+        for (const scope of scopes) {
+            const scoped = this.configurationService.getScopedMarketplaces(this.workdir, scope);
+            if (scoped[name])
+                return scope;
+        }
+        return null;
+    }
     /**
      * Adds a new marketplace (local directory, GitHub repo, or Git URL)
      */
-    async addMarketplace(input) {
+    async addMarketplace(input, scope = "user") {
         return this.withLock(async () => {
             let marketplace;
             const isFullUrl = input.startsWith("http://") ||
@@ -223,16 +332,15 @@ export class MarketplaceService {
                 (input.includes("/") &&
                     !path.isAbsolute(input) &&
                     !input.startsWith("."))) {
-                // Git or GitHub repo
                 let urlOrRepo = input;
                 let ref;
                 if (input.includes("#")) {
                     [urlOrRepo, ref] = input.split("#");
                 }
-                const tempMarketplace = isFullUrl
-                    ? { name: "", source: { source: "git", url: urlOrRepo, ref } }
-                    : { name: "", source: { source: "github", repo: urlOrRepo, ref } };
-                const targetPath = this.getMarketplacePath(tempMarketplace);
+                const tempSource = isFullUrl
+                    ? { source: "git", url: urlOrRepo, ref }
+                    : { source: "github", repo: urlOrRepo, ref };
+                const targetPath = this.getMarketplacePath(tempSource);
                 if (!existsSync(targetPath)) {
                     try {
                         await this.gitService.clone(urlOrRepo, targetPath, ref);
@@ -258,7 +366,6 @@ export class MarketplaceService {
                 };
             }
             else {
-                // Local directory format
                 const absolutePath = path.resolve(input);
                 let manifest;
                 try {
@@ -274,44 +381,68 @@ export class MarketplaceService {
                     lastUpdated: new Date().toISOString(),
                 };
             }
-            const registry = await this.getKnownMarketplaces();
-            // Check if already exists
-            const existingIndex = registry.marketplaces.findIndex((m) => m.name === marketplace.name);
-            if (existingIndex >= 0) {
-                registry.marketplaces[existingIndex] = marketplace;
-            }
-            else {
-                registry.marketplaces.push(marketplace);
-            }
-            // Ensure builtin is included if we are creating the file for the first time
-            // and it hasn't been explicitly removed yet.
-            // (getKnownMarketplaces already handles the default injection)
-            await this.saveKnownMarketplaces(registry);
+            const config = {
+                source: marketplace.source,
+                autoUpdate: marketplace.autoUpdate,
+            };
+            await this.configurationService.addMarketplaceToScope(this.workdir, scope, marketplace.name, config);
+            // Update cache with metadata
+            await this.updateCacheMarketplace(marketplace.name, {
+                source: marketplace.source,
+                autoUpdate: marketplace.autoUpdate,
+                lastUpdated: marketplace.lastUpdated,
+            });
             return marketplace;
         });
     }
     /**
-     * Lists all registered marketplaces
+     * Lists all registered marketplaces by combining scoped settings + built-in
      */
     async listMarketplaces() {
-        const registry = await this.getKnownMarketplaces();
-        return registry.marketplaces.map((m) => ({
-            ...m,
-            isBuiltin: m.name === MarketplaceService.BUILTIN_MARKETPLACE.name,
-        }));
+        const scopedMarketplaces = this.configurationService.getMergedMarketplaces(this.workdir);
+        const cacheRegistry = await this.getCacheRegistry();
+        const cacheMap = new Map((cacheRegistry?.marketplaces ?? []).map((m) => [m.name, m]));
+        const result = [];
+        // Add built-in marketplace
+        result.push({
+            ...MarketplaceService.BUILTIN_MARKETPLACE,
+            isBuiltin: true,
+            declaredScope: "builtin",
+        });
+        // Add all scoped marketplaces (local overrides project overrides user)
+        for (const [name, config] of Object.entries(scopedMarketplaces)) {
+            if (name === MarketplaceService.BUILTIN_MARKETPLACE.name)
+                continue;
+            const cache = cacheMap.get(name);
+            const declaredScope = this.getMarketplaceDeclaringSource(name);
+            result.push(await this.buildMarketplaceEntry(name, config, cache, declaredScope));
+        }
+        // Add cache entries not yet in scoped settings (backwards compatibility)
+        for (const [name, cache] of cacheMap.entries()) {
+            if (name === MarketplaceService.BUILTIN_MARKETPLACE.name)
+                continue;
+            if (scopedMarketplaces[name])
+                continue;
+            result.push({
+                ...cache,
+                isBuiltin: false,
+                declaredScope: cache.declaredScope ?? "user",
+            });
+        }
+        return result;
     }
     /**
-     * Removes a marketplace by name
+     * Removes a marketplace by name from the specified scope
      */
-    async removeMarketplace(name) {
+    async removeMarketplace(name, scope) {
         return this.withLock(async () => {
-            const registry = await this.getKnownMarketplaces();
-            const initialCount = registry.marketplaces.length;
-            registry.marketplaces = registry.marketplaces.filter((m) => m.name !== name);
-            if (registry.marketplaces.length === initialCount) {
-                throw new Error(`Marketplace ${name} not found`);
+            const targetScope = scope || this.getMarketplaceDeclaringSource(name) || "user";
+            if (targetScope === "builtin") {
+                throw new Error("Cannot remove built-in marketplace");
             }
-            await this.saveKnownMarketplaces(registry);
+            await this.configurationService.removeMarketplaceFromScope(this.workdir, targetScope, name);
+            // Also remove from cache
+            await this.removeFromCache(name);
         });
     }
     /**
@@ -319,10 +450,10 @@ export class MarketplaceService {
      */
     async updateMarketplace(name, options) {
         return this.withLock(async () => {
-            const registry = await this.getKnownMarketplaces();
+            const marketplaces = await this.listMarketplaces();
             const toUpdate = name
-                ? registry.marketplaces.filter((m) => m.name === name)
-                : registry.marketplaces;
+                ? marketplaces.filter((m) => m.name === name)
+                : marketplaces;
             if (name && toUpdate.length === 0) {
                 throw new Error(`Marketplace ${name} not found`);
             }
@@ -336,7 +467,7 @@ export class MarketplaceService {
                             console.warn(`Skipping update for Git/GitHub marketplace "${marketplace.name}" because Git is not installed.`);
                             continue;
                         }
-                        const targetPath = this.getMarketplacePath(marketplace);
+                        const targetPath = this.getMarketplacePath(marketplace.source);
                         if (existsSync(targetPath)) {
                             await this.gitService.pull(targetPath);
                         }
@@ -351,9 +482,12 @@ export class MarketplaceService {
                             await this.gitService.clone(url, targetPath, marketplace.source.ref);
                         }
                     }
-                    // For directory source, we just re-validate the manifest
-                    const manifest = await this.loadMarketplaceManifest(this.getMarketplacePath(marketplace));
+                    const manifest = await this.loadMarketplaceManifest(this.getMarketplacePath(marketplace.source));
                     marketplace.lastUpdated = new Date().toISOString();
+                    // Update cache metadata
+                    await this.updateCacheMarketplace(marketplace.name, {
+                        lastUpdated: marketplace.lastUpdated,
+                    });
                     if (options?.updatePlugins) {
                         const installedRegistry = await this.getInstalledPlugins();
                         const pluginsToUpdate = installedRegistry.plugins.filter((p) => p.marketplace === marketplace.name);
@@ -387,7 +521,6 @@ export class MarketplaceService {
             if (errors.length > 0) {
                 throw new Error(`Some marketplaces failed to update:\n${errors.join("\n")}`);
             }
-            await this.saveKnownMarketplaces(registry);
         });
     }
     /**
@@ -395,16 +528,18 @@ export class MarketplaceService {
      */
     async autoUpdateAll() {
         return this.withLock(async () => {
-            const registry = await this.getKnownMarketplaces();
-            const toAutoUpdate = registry.marketplaces.filter((m) => m.autoUpdate);
-            for (const marketplace of toAutoUpdate) {
+            const scopedMarketplaces = this.configurationService.getMergedMarketplaces(this.workdir);
+            const toAutoUpdate = Object.entries(scopedMarketplaces)
+                .filter(([, config]) => config.autoUpdate)
+                .map(([name]) => name);
+            for (const marketplaceName of toAutoUpdate) {
                 try {
-                    await this.updateMarketplace(marketplace.name, {
+                    await this.updateMarketplace(marketplaceName, {
                         updatePlugins: true,
                     });
                 }
                 catch (error) {
-                    console.error(`Auto-update failed for marketplace "${marketplace.name}":`, error);
+                    console.error(`Auto-update failed for marketplace "${marketplaceName}":`, error);
                 }
             }
         });
@@ -414,15 +549,74 @@ export class MarketplaceService {
      */
     async toggleAutoUpdate(name, enabled) {
         return this.withLock(async () => {
-            const registry = await this.getKnownMarketplaces();
-            const marketplace = registry.marketplaces.find((m) => m.name === name);
-            if (!marketplace) {
+            const declaringSource = this.getMarketplaceDeclaringSource(name);
+            if (!declaringSource || declaringSource === "builtin") {
+                throw new Error(`Marketplace ${name} not found`);
+            }
+            const scoped = this.configurationService.getScopedMarketplaces(this.workdir, declaringSource);
+            const config = scoped[name];
+            if (!config) {
                 throw new Error(`Marketplace ${name} not found`);
             }
-            marketplace.autoUpdate = enabled;
-            await this.saveKnownMarketplaces(registry);
+            config.autoUpdate = enabled;
+            await this.configurationService.addMarketplaceToScope(this.workdir, declaringSource, name, config);
+            // Also update cache
+            await this.updateCacheMarketplace(name, { autoUpdate: enabled });
         });
     }
+    /**
+     * Resolves a plugin source into a consistent format for installation.
+     * Handles both string sources (local paths or git URLs) and object-style MarketplaceSource.
+     */
+    resolvePluginSource(pluginEntry, marketplacePath) {
+        const { source } = pluginEntry;
+        if (typeof source === "string") {
+            // String source: could be a git URL or a relative local path
+            const isGitUrl = source.startsWith("http://") ||
+                source.startsWith("https://") ||
+                source.startsWith("git@") ||
+                source.startsWith("ssh://");
+            if (isGitUrl) {
+                let url = source;
+                let ref;
+                if (url.includes("#")) {
+                    [url, ref] = url.split("#");
+                }
+                return { isGit: true, url, ref, localPath: "" };
+            }
+            // Relative local path
+            return { isGit: false, localPath: path.resolve(marketplacePath, source) };
+        }
+        // Object-style source
+        if (source.source === "git") {
+            return { isGit: true, url: source.url, ref: source.ref, localPath: "" };
+        }
+        if (source.source === "github") {
+            return {
+                isGit: true,
+                url: `https://github.com/${source.repo}.git`,
+                ref: source.ref,
+                localPath: "",
+            };
+        }
+        if (source.source === "url") {
+            let url = source.url;
+            let ref = source.ref;
+            if (url.includes("#")) {
+                [url, ref] = url.split("#");
+            }
+            return { isGit: true, url, ref, localPath: "" };
+        }
+        if (source.source === "directory") {
+            return {
+                isGit: false,
+                localPath: path.resolve(marketplacePath, source.path),
+            };
+        }
+        // Exhaustiveness: this should be unreachable given the union type
+        const _exhaustive = source;
+        throw new Error(`Unsupported plugin source type: ${_exhaustive.source}`);
+    }
     /**
      * Installs a plugin from a marketplace
      */
@@ -437,45 +631,44 @@ export class MarketplaceService {
             if (!marketplace) {
                 throw new Error(`Marketplace ${marketplaceName} not found`);
             }
-            const marketplacePath = this.getMarketplacePath(marketplace);
+            const marketplacePath = this.getMarketplacePath(marketplace.source);
             const manifest = await this.loadMarketplaceManifest(marketplacePath);
             const pluginEntry = manifest.plugins.find((p) => p.name === pluginName);
             if (!pluginEntry) {
                 throw new Error(`Plugin ${pluginName} not found in marketplace ${marketplaceName}`);
             }
-            const isGitSource = pluginEntry.source.startsWith("http://") ||
-                pluginEntry.source.startsWith("https://") ||
-                pluginEntry.source.startsWith("git@") ||
-                pluginEntry.source.startsWith("ssh://");
+            const resolved = this.resolvePluginSource(pluginEntry, marketplacePath);
             let pluginSrcPath;
             let tempCloneDir;
             try {
-                if (isGitSource) {
+                if (resolved.isGit) {
                     tempCloneDir = path.join(this.tmpDir, `clone-${Date.now()}`);
-                    let url = pluginEntry.source;
-                    let ref;
-                    if (url.includes("#")) {
-                        [url, ref] = url.split("#");
-                    }
-                    await this.gitService.clone(url, tempCloneDir, ref);
+                    await this.gitService.clone(resolved.url, tempCloneDir, resolved.ref);
                     pluginSrcPath = tempCloneDir;
                 }
                 else {
-                    pluginSrcPath = path.resolve(marketplacePath, pluginEntry.source);
+                    pluginSrcPath = resolved.localPath;
+                }
+                let pluginManifestPath;
+                const wavePluginPath = path.join(pluginSrcPath, ".wave-plugin", "plugin.json");
+                const claudePluginPath = path.join(pluginSrcPath, ".claude-plugin", "plugin.json");
+                if (existsSync(wavePluginPath)) {
+                    pluginManifestPath = wavePluginPath;
+                }
+                else if (existsSync(claudePluginPath)) {
+                    pluginManifestPath = claudePluginPath;
                 }
-                const pluginManifestPath = path.join(pluginSrcPath, ".wave-plugin", "plugin.json");
-                if (!existsSync(pluginManifestPath)) {
-                    throw new Error(`Plugin manifest not found at ${pluginManifestPath}`);
+                if (!pluginManifestPath) {
+                    throw new Error(`Plugin manifest not found at ${pluginSrcPath}. Neither .wave-plugin/plugin.json nor .claude-plugin/plugin.json exists.`);
                 }
                 const pluginManifestContent = await fs.readFile(pluginManifestPath, "utf-8");
                 const pluginManifest = JSON.parse(pluginManifestContent);
                 const version = pluginManifest.version || "1.0.0";
-                // Atomic installation
                 const tmpPluginDir = path.join(this.tmpDir, `${pluginName}-${Date.now()}`);
                 try {
-                    if (isGitSource) {
+                    if (resolved.isGit) {
                         await fs.rename(pluginSrcPath, tmpPluginDir);
-                        tempCloneDir = undefined; // Already moved
+                        tempCloneDir = undefined;
                     }
                     else {
                         await fs.cp(pluginSrcPath, tmpPluginDir, { recursive: true });
@@ -507,7 +700,6 @@ export class MarketplaceService {
                     return installedPlugin;
                 }
                 catch (error) {
-                    // Cleanup tmp dir if it exists
                     if (existsSync(tmpPluginDir)) {
                         await fs.rm(tmpPluginDir, { recursive: true, force: true });
                     }
@@ -515,7 +707,6 @@ export class MarketplaceService {
                 }
             }
             catch (error) {
-                // Cleanup temp clone dir if it exists
                 if (tempCloneDir && existsSync(tempCloneDir)) {
                     await fs.rm(tempCloneDir, { recursive: true, force: true });
                 }
@@ -540,12 +731,9 @@ export class MarketplaceService {
                 throw new Error(`Plugin ${pluginName}@${marketplaceName} is not installed${projectPath ? ` for project ${projectPath}` : ""}`);
             }
             const pluginToRemove = installedRegistry.plugins[pluginIndex];
-            // Remove from registry first
             installedRegistry.plugins.splice(pluginIndex, 1);
             await this.saveInstalledPlugins(installedRegistry);
-            // Check if any other project is still using this same cache path
             const isStillReferenced = installedRegistry.plugins.some((p) => p.cachePath === pluginToRemove.cachePath);
-            // Only remove cached files if no other references exist
             if (!isStillReferenced && existsSync(pluginToRemove.cachePath)) {
                 await fs.rm(pluginToRemove.cachePath, { recursive: true, force: true });
             }