wave-agent-sdk 0.14.0 → 0.14.1

package/src/services/configurationService.ts

@@ -15,6 +15,7 @@ import type {
   ConfigurationPaths,
   WaveConfiguration,
   Scope,
+  MarketplaceConfig,
 } from "../types/configuration.js";
 import {
   getAllConfigPaths,
@@ -796,6 +797,124 @@ export class ConfigurationService {
     await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
   }
 
+  /**
+   * Get merged marketplaces from all scopes
+   */
+  getMergedMarketplaces(workdir: string): Record<string, MarketplaceConfig> {
+    const mergedConfig = loadMergedWaveConfig(workdir);
+    return mergedConfig?.marketplaces || {};
+  }
+
+  /**
+   * Get marketplaces at a specific scope
+   */
+  getScopedMarketplaces(
+    workdir: string,
+    scope: Scope,
+  ): Record<string, MarketplaceConfig> {
+    let configPath: string;
+    if (scope === "user") {
+      configPath = getUserConfigPaths()[0];
+    } else if (scope === "project") {
+      configPath = getProjectConfigPaths(workdir)[1];
+    } else {
+      configPath = getProjectConfigPaths(workdir)[0];
+    }
+    const config = loadWaveConfigFromFile(configPath);
+    return config?.marketplaces || {};
+  }
+
+  /**
+   * Add a marketplace to the specified scope
+   */
+  async addMarketplaceToScope(
+    workdir: string,
+    scope: Scope,
+    name: string,
+    config: MarketplaceConfig,
+  ): Promise<void> {
+    if (scope !== "user" && !existsSync(workdir)) {
+      throw new Error(`Working directory does not exist: ${workdir}`);
+    }
+
+    let configPath: string;
+    if (scope === "user") {
+      configPath = getUserConfigPaths()[0];
+    } else if (scope === "project") {
+      configPath = getProjectConfigPaths(workdir)[1];
+    } else {
+      configPath = getProjectConfigPaths(workdir)[0];
+    }
+
+    const configDir = path.dirname(configPath);
+    if (!existsSync(configDir)) {
+      await fs.mkdir(configDir, { recursive: true });
+    }
+
+    let fileConfig: WaveConfiguration = {};
+    if (existsSync(configPath)) {
+      try {
+        const content = await fs.readFile(configPath, "utf-8");
+        fileConfig = JSON.parse(content);
+      } catch {
+        // Start with empty config if file is corrupted
+      }
+    }
+
+    if (!fileConfig.marketplaces) {
+      fileConfig.marketplaces = {};
+    }
+    fileConfig.marketplaces[name] = config;
+
+    await fs.writeFile(
+      configPath,
+      JSON.stringify(fileConfig, null, 2),
+      "utf-8",
+    );
+  }
+
+  /**
+   * Remove a marketplace from the specified scope
+   */
+  async removeMarketplaceFromScope(
+    workdir: string,
+    scope: Scope,
+    name: string,
+  ): Promise<void> {
+    if (scope !== "user" && !existsSync(workdir)) {
+      throw new Error(`Working directory does not exist: ${workdir}`);
+    }
+
+    let configPath: string;
+    if (scope === "user") {
+      configPath = getUserConfigPaths()[0];
+    } else if (scope === "project") {
+      configPath = getProjectConfigPaths(workdir)[1];
+    } else {
+      configPath = getProjectConfigPaths(workdir)[0];
+    }
+
+    if (!existsSync(configPath)) {
+      return;
+    }
+
+    try {
+      const content = await fs.readFile(configPath, "utf-8");
+      const fileConfig: WaveConfiguration = JSON.parse(content);
+
+      if (fileConfig.marketplaces && name in fileConfig.marketplaces) {
+        delete fileConfig.marketplaces[name];
+        await fs.writeFile(
+          configPath,
+          JSON.stringify(fileConfig, null, 2),
+          "utf-8",
+        );
+      }
+    } catch {
+      // Ignore errors for corrupted or non-existent files
+    }
+  }
+
   /**
    * Remove a plugin from the enabled plugins in the specified scope
    */
@@ -991,6 +1110,7 @@ export function loadWaveConfigFromFile(
           ? config.autoMemoryEnabled
           : undefined,
       models: config.models || undefined,
+      marketplaces: config.marketplaces || undefined,
     };
   } catch (error) {
     if (error instanceof SyntaxError) {
@@ -1124,6 +1244,12 @@ export function loadMergedWaveConfig(
       mergedConfig.autoMemoryFrequency = config.autoMemoryFrequency;
     }
 
+    // Merge marketplaces (last one wins for same key)
+    if (config.marketplaces) {
+      if (!mergedConfig.marketplaces) mergedConfig.marketplaces = {};
+      Object.assign(mergedConfig.marketplaces, config.marketplaces);
+    }
+
     // Merge models
     if (config.models) {
       if (!mergedConfig.models) mergedConfig.models = {};
@@ -1157,6 +1283,11 @@ export function loadMergedWaveConfig(
         : undefined,
     language: mergedConfig.language,
     autoMemoryEnabled: mergedConfig.autoMemoryEnabled,
+    marketplaces:
+      mergedConfig.marketplaces &&
+      Object.keys(mergedConfig.marketplaces).length > 0
+        ? mergedConfig.marketplaces
+        : undefined,
     models:
       mergedConfig.models && Object.keys(mergedConfig.models).length > 0
         ? mergedConfig.models

package/src/services/pluginLoader.ts

@@ -1,4 +1,5 @@
 import * as fs from "fs/promises";
+import * as fsSync from "fs";
 import * as path from "path";
 import {
   PluginManifest,
@@ -13,21 +14,79 @@ import { parseSkillFile } from "../utils/skillParser.js";
 import { resolveMcpConfig } from "../managers/mcpManager.js";
 
 export class PluginLoader {
+  /**
+   * Finds the first existing plugin manifest path.
+   * Prefers .wave-plugin/ for backward compatibility, falls back to .claude-plugin/.
+   * Returns null if neither exists.
+   */
+  private static findPluginManifestPath(pluginPath: string): string | null {
+    const waveManifestPath = path.join(
+      pluginPath,
+      ".wave-plugin",
+      "plugin.json",
+    );
+    const claudeManifestPath = path.join(
+      pluginPath,
+      ".claude-plugin",
+      "plugin.json",
+    );
+
+    // Check .wave-plugin first for backward compatibility
+    try {
+      const waveStat = fsSync.statSync(waveManifestPath);
+      if (waveStat.isFile()) {
+        return waveManifestPath;
+      }
+    } catch {
+      // .wave-plugin/plugin.json doesn't exist
+    }
+
+    try {
+      const claudeStat = fsSync.statSync(claudeManifestPath);
+      if (claudeStat.isFile()) {
+        return claudeManifestPath;
+      }
+    } catch {
+      // .claude-plugin/plugin.json doesn't exist
+    }
+
+    return null;
+  }
+
   /**
    * Load and validate a plugin manifest from a directory
    * @param pluginPath Absolute path to the plugin directory
    */
   static async loadManifest(pluginPath: string): Promise<PluginManifest> {
-    const dotWavePluginPath = path.join(pluginPath, ".wave-plugin");
-    const manifestPath = path.join(dotWavePluginPath, "plugin.json");
+    const manifestPath = this.findPluginManifestPath(pluginPath);
+    if (!manifestPath) {
+      throw new Error(
+        `Plugin manifest not found at ${pluginPath}. Neither .wave-plugin/plugin.json nor .claude-plugin/plugin.json exists.`,
+      );
+    }
 
-    // T018: Ensure plugin.json is the only file in .wave-plugin/
+    // Determine which directory is being used for validation
+    const pluginDirName = manifestPath.includes(".claude-plugin")
+      ? ".claude-plugin"
+      : ".wave-plugin";
+    const pluginDirPath = path.join(pluginPath, pluginDirName);
+
+    // T018: Ensure plugin.json is the only file in the manifest directory
+    // For .claude-plugin/, marketplace.json is also allowed (Claude Code convention)
     try {
-      const entries = await fs.readdir(dotWavePluginPath);
-      const misplaced = entries.filter((e) => e !== "plugin.json");
+      const entries = await fs.readdir(pluginDirPath);
+      const allowedFiles = ["plugin.json"];
+      if (pluginDirName === ".claude-plugin") {
+        allowedFiles.push("marketplace.json");
+      }
+      const misplaced = entries.filter((e) => !allowedFiles.includes(e));
       if (misplaced.length > 0) {
+        const allowedMsg =
+          pluginDirName === ".claude-plugin"
+            ? "Only plugin.json and marketplace.json should be in this directory."
+            : "Only plugin.json should be in this directory.";
         throw new Error(
-          `Misplaced files/directories in .wave-plugin/: ${misplaced.join(", ")}. Only plugin.json should be in this directory.`,
+          `Misplaced files/directories in ${pluginDirName}/: ${misplaced.join(", ")}. ${allowedMsg}`,
         );
       }
     } catch (error) {
@@ -36,7 +95,7 @@ export class PluginLoader {
         (error as { code?: string }).code === "ENOENT"
       ) {
         throw new Error(
-          `Plugin manifest directory not found at ${dotWavePluginPath}`,
+          `Plugin manifest directory not found at ${pluginDirPath}`,
         );
       }
       throw error;

package/src/types/configuration.ts

@@ -9,9 +9,15 @@
 import type { HookEvent, HookEventConfig } from "./hooks.js";
 import type { PermissionMode } from "./permissions.js";
 import type { ModelConfig } from "./config.js";
+import type { MarketplaceSource } from "./marketplace.js";
 
 export type Scope = "user" | "project" | "local";
 
+export interface MarketplaceConfig {
+  source: MarketplaceSource;
+  autoUpdate?: boolean;
+}
+
 /**
  * Root configuration structure for all Wave Agent settings including hooks and environment variables
  */
@@ -39,6 +45,8 @@ export interface WaveConfiguration {
   autoMemoryFrequency?: number;
   /** Model-specific configuration overrides */
   models?: Record<string, Partial<ModelConfig>>;
+  /** Scoped marketplace declarations */
+  marketplaces?: Record<string, MarketplaceConfig>;
 }
 
 /**

package/src/types/marketplace.ts

@@ -7,8 +7,24 @@ export interface MarketplaceOwner {
 
 export interface MarketplacePluginEntry {
   name: string;
-  source: string;
+  source: string | MarketplaceSource;
   description: string;
+  /** Claude Code compatibility: plugin category */
+  category?: string;
+  /** Claude Code compatibility: plugin tags */
+  tags?: string[];
+  /** Claude Code compatibility: when false, plugin.json is optional */
+  strict?: boolean;
+  /** Claude Code compatibility: inline manifest fields */
+  version?: string;
+  author?: { name: string; url?: string };
+  homepage?: string;
+  repository?: string;
+  license?: string;
+  keywords?: string[];
+  commands?: string;
+  skills?: string;
+  agents?: string;
 }
 
 export interface MarketplacePluginStatus extends MarketplacePluginEntry {
@@ -24,6 +40,8 @@ export interface MarketplaceManifest {
   name: string;
   owner: MarketplaceOwner;
   plugins: MarketplacePluginEntry[];
+  /** Claude Code compatibility: additional metadata */
+  metadata?: Record<string, unknown>;
 }
 
 export type MarketplaceSource =
@@ -40,6 +58,11 @@ export type MarketplaceSource =
       source: "git";
       url: string;
       ref?: string;
+    }
+  | {
+      source: "url";
+      url: string;
+      ref?: string;
     };
 
 export interface KnownMarketplace {
@@ -48,6 +71,8 @@ export interface KnownMarketplace {
   isBuiltin?: boolean;
   autoUpdate?: boolean;
   lastUpdated?: string;
+  /** The scope where this marketplace was declared (user, project, local, or builtin) */
+  declaredScope?: "user" | "project" | "local" | "builtin";
 }
 
 export interface KnownMarketplacesRegistry {

package/src/types/plugins.ts

@@ -5,7 +5,7 @@ import { McpConfig } from "./mcp.js";
 import { PartialHookConfiguration } from "./configuration.js";
 
 /**
- * Plugin manifest structure (.wave-plugin/plugin.json)
+ * Plugin manifest structure (.wave-plugin/plugin.json or .claude-plugin/plugin.json)
  */
 export interface PluginManifest {
   name: string;
@@ -14,6 +14,18 @@ export interface PluginManifest {
   author?: {
     name: string;
   };
+  /** Claude Code compatibility: plugin keywords */
+  keywords?: string[];
+  /** Claude Code compatibility: plugin homepage URL */
+  homepage?: string;
+  /** Claude Code compatibility: repository info */
+  repository?: string;
+  /** Claude Code compatibility: license info */
+  license?: string;
+  /** Claude Code compatibility: plugin dependencies */
+  dependencies?: Record<string, string>;
+  /** Claude Code compatibility: user configuration schema */
+  userConfig?: Record<string, unknown>;
 }
 
 /**