wave-agent-sdk 0.13.6 → 0.14.1

package/src/services/aiService.ts

@@ -784,6 +784,19 @@ export async function compressMessages(
     await acquireSlot(abortSignal);
   }
 
+  // Strip images from messages before compact API call to reduce token usage
+  const cleanedMessages = messages.map((msg) => {
+    // Handle user/assistant messages with array content
+    if (Array.isArray(msg.content)) {
+      const textParts = msg.content.filter(
+        (part) => part.type === "text",
+      ) as import("openai/resources.js").ChatCompletionContentPartText[];
+      const text = textParts.map((p) => p.text).join("\n");
+      return { ...msg, content: text || "(empty message)" };
+    }
+    return msg;
+  });
+
   // Create OpenAI client with injected configuration
   const openai = new OpenAIClient({
     apiKey: gatewayConfig.apiKey,
@@ -821,7 +834,7 @@ export async function compressMessages(
             role: "system",
             content: COMPRESS_MESSAGES_SYSTEM_PROMPT,
           },
-          ...messages,
+          ...cleanedMessages,
           {
             role: "user",
             content: `Please create a detailed summary of the conversation so far.`,

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/tools/agentTool.ts

@@ -71,7 +71,11 @@ When using the Agent tool, you must specify a subagent_type parameter to select
 
 - When doing file search, prefer to use the ${AGENT_TOOL_NAME} tool in order to reduce context usage.
 - You should proactively use the ${AGENT_TOOL_NAME} tool with specialized agents when the task at hand matches the agent's description.
-- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${AGENT_TOOL_NAME} tool with subagent_type=${EXPLORE_SUBAGENT_TYPE} instead of running search commands directly.`;
+- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${AGENT_TOOL_NAME} tool with subagent_type=${EXPLORE_SUBAGENT_TYPE} instead of running search commands directly.
+- You can optionally run agents in the background using the run_in_background parameter. When an agent runs in the background, you will be automatically notified when it completes — do NOT sleep, poll, or proactively check on its progress. Continue with other work or respond to the user instead.
+- **Foreground vs background**: Use foreground (default) when you need the agent's results before you can proceed — e.g., research agents whose findings inform your next steps. Use background when you have genuinely independent work to do in parallel.
+- **Don't peek.** The tool result includes an output file path — do not Read or tail it unless the user explicitly asks for a progress check. You get a completion notification; trust it. Reading the transcript mid-flight pulls the agent's tool noise into your context, which defeats the point of backgrounding.
+- **Don't race.** After launching, you know nothing about what the agent found. Never fabricate or predict agent results in any format — not as prose, summary, or structured output. The notification arrives as a user-role message in a later turn; it is never something you write yourself. If the user asks a follow-up before the notification lands, tell them the agent is still running — give status, not a guess.`;
   },
 
   execute: async (
@@ -212,9 +216,17 @@ When using the Agent tool, you must specify a subagent_type parameter to select
             if (run_in_background) {
               const task = context.backgroundTaskManager?.getTask(result);
               const outputPath = task?.outputPath;
+              const backgroundMsg = [
+                `Agent started in background with ID: ${result}.`,
+                `The agent is working in the background. You will be notified automatically when it completes.`,
+                `Do not duplicate this agent's work — avoid working with the same files or topics it is using.`,
+                outputPath
+                  ? `output_file: ${outputPath}`
+                  : `Briefly tell the user what you launched and end your response.`,
+              ].join("\n");
               resolve({
                 success: true,
-                content: `Agent started in background with ID: ${result}.${outputPath ? ` Real-time output: ${outputPath}` : ""}`,
+                content: backgroundMsg,
                 shortResult: `Agent started in background: ${result}`,
               });
               return;

package/src/tools/bashTool.ts

@@ -139,7 +139,10 @@ Use the gh command via the Bash tool for GitHub-related tasks including working
 - Do not retry failing commands in a sleep loop — diagnose the root cause.
 - If waiting for a background task you started with \`run_in_background\`, you will be notified when it completes — do not poll.
 - If you must poll an external process, use a check command (e.g. \`gh run view\`) rather than sleeping first.
-- If you must sleep, keep the duration short (1-5 seconds) to avoid blocking the user.`,
+- If you must sleep, keep the duration short (1-5 seconds) to avoid blocking the user.
+
+# CWD management
+Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of \`cd\`. You may use \`cd\` if the User explicitly requests it. When you use \`cd\`, the shell working directory will be reset to the original working directory after the command completes.`,
   execute: async (
     args: Record<string, unknown>,
     context: ToolContext,
@@ -221,9 +224,16 @@ Use the gh command via the Bash tool for GitHub-related tasks including working
       const { id: taskId } = backgroundTaskManager.startShell(command, timeout);
       const task = backgroundTaskManager.getTask(taskId);
       const outputPath = task?.outputPath;
+      const backgroundMsg = [
+        `Command started in background with ID: ${taskId}.`,
+        `You will be notified automatically when it completes.`,
+        outputPath
+          ? `output_file: ${outputPath}`
+          : `Use ${READ_TOOL_NAME} tool with task_id="${taskId}" to read the output.`,
+      ].join("\n");
       return {
         success: true,
-        content: `Command started in background with ID: ${taskId}.${outputPath ? ` Real-time output: ${outputPath}` : ` Use ${READ_TOOL_NAME} tool with task_id="${taskId}" to monitor output.`}`,
+        content: backgroundMsg,
         shortResult: `Background process ${taskId} started`,
       };
     }
@@ -446,9 +456,20 @@ Use the gh command via the Bash tool for GitHub-related tasks including working
             }
           }
 
-          // If CWD changed, call the onCwdChange callback
+          // If CWD changed, call the onCwdChange callback and add notification
+          let cwdChangedNotification = "";
           if (newCwd && newCwd !== context.workdir && context.onCwdChange) {
-            context.onCwdChange(newCwd);
+            const isInSafeZone =
+              context.permissionManager?.isPathInSafeZone?.(newCwd) ?? true;
+
+            if (isInSafeZone) {
+              context.onCwdChange(newCwd);
+            } else if (context.originalWorkdir) {
+              context.onCwdChange(context.originalWorkdir);
+              cwdChangedNotification = `Shell cwd was reset to ${context.originalWorkdir}\n`;
+            } else {
+              context.onCwdChange(newCwd);
+            }
           }
 
           const exitCode = code ?? 0;
@@ -457,7 +478,8 @@ Use the gh command via the Bash tool for GitHub-related tasks including working
 
           // Handle large output by truncation and persistence if needed
           const finalOutput =
-            combinedOutput || `Command executed with exit code: ${exitCode}`;
+            cwdChangedNotification +
+            (combinedOutput || `Command executed with exit code: ${exitCode}`);
           const content = processOutput(finalOutput);
 
           const lines = combinedOutput.trim().split("\n");

package/src/tools/types.ts

@@ -58,6 +58,7 @@ export interface ToolContext {
   abortSignal?: AbortSignal;
   backgroundTaskManager?: import("../managers/backgroundTaskManager.js").BackgroundTaskManager;
   workdir: string;
+  originalWorkdir?: string;
   /** Permission mode for this tool execution */
   permissionMode?: PermissionMode;
   /** Custom permission callback */