wave-agent-sdk 0.9.6 → 0.10.0

package/src/managers/backgroundTaskManager.ts

@@ -1,4 +1,7 @@
 import { spawn, type ChildProcess } from "child_process";
+import * as os from "os";
+import * as fs from "fs";
+import * as path from "path";
 import { BackgroundTask, BackgroundShell } from "../types/processes.js";
 import { stripAnsiColors } from "../utils/stringUtils.js";
 import { logger } from "../utils/globalLogger.js";
@@ -64,6 +67,10 @@ export class BackgroundTaskManager {
       },
     });
 
+    // Create log file
+    const logPath = path.join(os.tmpdir(), `wave-task-${id}.log`);
+    const logStream = fs.createWriteStream(logPath, { flags: "a" });
+
     const shell: BackgroundShell = {
       id,
       type: "shell",
@@ -73,8 +80,10 @@ export class BackgroundTaskManager {
       status: "running",
       stdout: "",
       stderr: "",
+      outputPath: logPath,
       onStop: () => {
         try {
+          logStream.end();
           if (child.pid) {
             process.kill(-child.pid, "SIGTERM");
             setTimeout(() => {
@@ -109,12 +118,20 @@ export class BackgroundTaskManager {
     }
 
     const onStdout = (data: Buffer | string) => {
-      shell.stdout += stripAnsiColors(data.toString());
+      const stripped = stripAnsiColors(data.toString());
+      shell.stdout += stripped;
+      if (logStream.writable) {
+        logStream.write(stripped);
+      }
       this.notifyTasksChange();
     };
 
     const onStderr = (data: Buffer | string) => {
-      shell.stderr += stripAnsiColors(data.toString());
+      const stripped = stripAnsiColors(data.toString());
+      shell.stderr += stripped;
+      if (logStream.writable) {
+        logStream.write(stripped);
+      }
       this.notifyTasksChange();
     };
 
@@ -122,6 +139,9 @@ export class BackgroundTaskManager {
       if (timeoutHandle) {
         clearTimeout(timeoutHandle);
       }
+      if (logStream.writable) {
+        logStream.end();
+      }
       shell.status = code === 0 ? "completed" : "failed";
       shell.exitCode = code ?? 0;
       shell.endTime = Date.now();
@@ -133,8 +153,13 @@ export class BackgroundTaskManager {
       if (timeoutHandle) {
         clearTimeout(timeoutHandle);
       }
+      const stripped = `\nProcess error: ${stripAnsiColors(error.message)}`;
       shell.status = "failed";
-      shell.stderr += `\nProcess error: ${stripAnsiColors(error.message)}`;
+      shell.stderr += stripped;
+      if (logStream.writable) {
+        logStream.write(stripped);
+        logStream.end();
+      }
       shell.exitCode = 1;
       shell.endTime = Date.now();
       shell.runtime = shell.endTime - startTime;
@@ -154,6 +179,7 @@ export class BackgroundTaskManager {
       if (timeoutHandle) {
         clearTimeout(timeoutHandle);
       }
+      logStream.end();
       this.tasks.delete(id);
       this.notifyTasksChange();
     };
@@ -170,6 +196,18 @@ export class BackgroundTaskManager {
     const id = this.generateId();
     const startTime = Date.now();
 
+    // Create log file
+    const logPath = path.join(os.tmpdir(), `wave-task-${id}.log`);
+    const logStream = fs.createWriteStream(logPath, { flags: "a" });
+
+    // Write initial output to log file
+    if (initialStdout) {
+      logStream.write(stripAnsiColors(initialStdout));
+    }
+    if (initialStderr) {
+      logStream.write(stripAnsiColors(initialStderr));
+    }
+
     const shell: BackgroundShell = {
       id,
       type: "shell",
@@ -179,8 +217,10 @@ export class BackgroundTaskManager {
       status: "running",
       stdout: initialStdout,
       stderr: initialStderr,
+      outputPath: logPath,
       onStop: () => {
         try {
+          logStream.end();
           if (child.pid) {
             process.kill(-child.pid, "SIGTERM");
             setTimeout(() => {
@@ -205,16 +245,27 @@ export class BackgroundTaskManager {
     this.notifyTasksChange();
 
     child.stdout?.on("data", (data) => {
-      shell.stdout += stripAnsiColors(data.toString());
+      const stripped = stripAnsiColors(data.toString());
+      shell.stdout += stripped;
+      if (logStream.writable) {
+        logStream.write(stripped);
+      }
       this.notifyTasksChange();
     });
 
     child.stderr?.on("data", (data) => {
-      shell.stderr += stripAnsiColors(data.toString());
+      const stripped = stripAnsiColors(data.toString());
+      shell.stderr += stripped;
+      if (logStream.writable) {
+        logStream.write(stripped);
+      }
       this.notifyTasksChange();
     });
 
     child.on("exit", (code) => {
+      if (logStream.writable) {
+        logStream.end();
+      }
       shell.status = code === 0 ? "completed" : "failed";
       shell.exitCode = code ?? 0;
       shell.endTime = Date.now();
@@ -223,8 +274,13 @@ export class BackgroundTaskManager {
     });
 
     child.on("error", (error) => {
+      const stripped = `\nProcess error: ${stripAnsiColors(error.message)}`;
       shell.status = "failed";
-      shell.stderr += `\nProcess error: ${stripAnsiColors(error.message)}`;
+      shell.stderr += stripped;
+      if (logStream.writable) {
+        logStream.write(stripped);
+        logStream.end();
+      }
       shell.exitCode = 1;
       shell.endTime = Date.now();
       shell.runtime = shell.endTime - startTime;

package/src/managers/messageManager.ts

@@ -3,6 +3,7 @@ import {
   updateToolBlockInMessage,
   addErrorBlockToMessage,
   addUserMessageToMessages,
+  updateUserMessageInMessages,
   addBangMessage,
   updateBangInMessage,
   completeBangInMessage,
@@ -318,15 +319,29 @@ export class MessageManager {
   }
 
   // Encapsulated message operation functions
-  public addUserMessage(params: UserMessageParams): void {
+  public addUserMessage(params: UserMessageParams): string {
+    const id = generateMessageId();
     const newMessages = addUserMessageToMessages({
       messages: this.messages,
       ...params,
+      id,
     });
     this.setMessages(newMessages);
     this.callbacks.onUserMessageAdded?.(params);
 
     // Note: Subagent-specific callbacks are now handled by SubagentManager
+    return id;
+  }
+
+  /**
+   * Update an existing user message by its ID.
+   */
+  public updateUserMessage(
+    id: string,
+    params: Partial<UserMessageParams>,
+  ): void {
+    const newMessages = updateUserMessageInMessages(this.messages, id, params);
+    this.setMessages(newMessages);
   }
 
   public addAssistantMessage(

package/src/managers/pluginManager.ts

@@ -164,7 +164,7 @@ export class PluginManager {
       }
 
       if (this.skillManager && plugin.skills.length > 0) {
-        this.skillManager.registerPluginSkills(plugin.skills);
+        this.skillManager.registerPluginSkills(plugin.name, plugin.skills);
       }
 
       if (this.lspManager && plugin.lspConfig) {

package/src/managers/skillManager.ts

@@ -243,8 +243,18 @@ export class SkillManager {
       const entries = await readdir(skillsPath, { withFileTypes: true });
 
       for (const entry of entries) {
+        const fullPath = join(skillsPath, entry.name);
         if (entry.isDirectory()) {
-          directories.push(join(skillsPath, entry.name));
+          directories.push(fullPath);
+        } else if (entry.isSymbolicLink()) {
+          try {
+            const s = await stat(fullPath);
+            if (s.isDirectory()) {
+              directories.push(fullPath);
+            }
+          } catch {
+            // Ignore broken symlinks or other errors
+          }
         }
       }
     } catch {
@@ -262,12 +272,48 @@ export class SkillManager {
     context?: SkillInvocationContext;
     allowedTools?: string[];
   }> {
-    const { skill_name, args: skillArgs } = args;
+    const { skill_name } = args;
+
+    logger?.debug(`Invoking skill: ${skill_name}`);
 
-    logger?.debug(`Invoking skill: ${skill_name} with args: ${skillArgs}`);
+    const prepared = await this.prepareSkill(args);
+    if (!prepared.skill) {
+      return { content: prepared.content };
+    }
+
+    try {
+      const finalContent = await this.executeBashInSkillContent(
+        prepared.content,
+      );
+
+      return {
+        content: finalContent,
+        context: {
+          skillName: skill_name,
+        },
+        allowedTools: prepared.skill.allowedTools,
+      };
+    } catch (error) {
+      logger?.error(`Failed to execute skill '${skill_name}':`, error);
+      return {
+        content: `❌ **Error executing skill**: ${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+  }
+
+  /**
+   * Prepare a skill by name without executing bash commands
+   */
+  async prepareSkill(args: SkillToolArgs): Promise<
+    | {
+        content: string;
+        skill: Skill;
+      }
+    | { content: string; skill?: undefined }
+  > {
+    const { skill_name, args: skillArgs } = args;
 
     try {
-      // Load the skill
       const skill = await this.loadSkill(skill_name);
 
       if (!skill) {
@@ -283,35 +329,20 @@ export class SkillManager {
         };
       }
 
-      // Process skill content with arguments and bash commands
-      const processedContent = await this.processSkillContent(
-        skill,
-        skillArgs || "",
-      );
-
-      // Return skill content with context
-      return {
-        content: processedContent,
-        context: {
-          skillName: skill_name,
-        },
-        allowedTools: skill.allowedTools,
-      };
+      const preparedContent = this.prepareSkillContent(skill, skillArgs || "");
+      return { content: preparedContent, skill };
     } catch (error) {
-      logger?.error(`Failed to execute skill '${skill_name}':`, error);
+      logger?.error(`Failed to prepare skill '${skill_name}':`, error);
       return {
-        content: `❌ **Error executing skill**: ${error instanceof Error ? error.message : String(error)}`,
+        content: `❌ **Error preparing skill**: ${error instanceof Error ? error.message : String(error)}`,
       };
     }
   }
 
   /**
-   * Process skill content with arguments and bash commands
+   * Prepare skill content with arguments but without bash execution
    */
-  private async processSkillContent(
-    skill: Skill,
-    argsString: string,
-  ): Promise<string> {
+  private prepareSkillContent(skill: Skill, argsString: string): string {
     const header = `🧠 **${skill.name}** (${skill.type} skill)\n\n`;
     const description = `*${skill.description}*\n\n`;
     const skillPath = `📁 Skill location: \`${skill.skillPath}\`\n\n`;
@@ -326,14 +357,19 @@ export class SkillManager {
     // 2. Substitute ${WAVE_SKILL_DIR} with the skill's directory path
     mainContent = mainContent.replace(/\$\{WAVE_SKILL_DIR\}/g, skill.skillPath);
 
-    // 3. Parse and execute bash commands (!`command`)
-    const { commands } = parseBashCommands(mainContent);
+    return header + description + skillPath + mainContent;
+  }
+
+  /**
+   * Execute bash commands in prepared skill content
+   */
+  private async executeBashInSkillContent(content: string): Promise<string> {
+    const { commands } = parseBashCommands(content);
     if (commands.length > 0) {
       const results = await executeBashCommands(commands, this.workdir);
-      mainContent = replaceBashCommandsWithOutput(mainContent, results);
+      return replaceBashCommandsWithOutput(content, results);
     }
-
-    return header + description + skillPath + mainContent;
+    return content;
   }
 
   /**
@@ -356,10 +392,11 @@ export class SkillManager {
   /**
    * Register skills provided by a plugin
    */
-  registerPluginSkills(skills: Skill[]): void {
+  registerPluginSkills(pluginName: string, skills: Skill[]): void {
     for (const skill of skills) {
+      const namespacedName = `${pluginName}:${skill.name}`;
       const metadata: SkillMetadata = {
-        name: skill.name,
+        name: namespacedName,
         description: skill.description,
         type: skill.type,
         skillPath: skill.skillPath,
@@ -369,12 +406,16 @@ export class SkillManager {
         model: skill.model,
         disableModelInvocation: skill.disableModelInvocation,
         userInvocable: skill.userInvocable,
+        pluginName,
       };
-      this.skillMetadata.set(skill.name, metadata);
-      this.skillContent.set(skill.name, skill);
+      // Update the skill object itself to have the namespaced name
+      skill.name = namespacedName;
+
+      this.skillMetadata.set(namespacedName, metadata);
+      this.skillContent.set(namespacedName, skill);
     }
     logger?.debug(
-      `Registered ${skills.length} plugin skills. Total skills: ${this.skillMetadata.size}`,
+      `Registered ${skills.length} plugin skills from ${pluginName}. Total skills: ${this.skillMetadata.size}`,
     );
   }
 }

package/src/managers/slashCommandManager.ts

@@ -154,21 +154,39 @@ export class SlashCommandManager {
         description: `Skill: ${skill.description}`,
         handler: async (args?: string) => {
           try {
-            const result = await this.skillManager.executeSkill({
+            // 1. Prepare skill content immediately
+            const prepared = await this.skillManager.prepareSkill({
               skill_name: skill.name,
               args,
             });
 
-            // Add user message with skill content
             const originalInput = args
               ? `/${skill.name} ${args}`
               : `/${skill.name}`;
-            this.messageManager.addUserMessage({
+
+            // 2. Add user message immediately
+            const messageId = this.messageManager.addUserMessage({
               content: originalInput,
+              customCommandContent: prepared.content,
+            });
+
+            if (!prepared.skill) {
+              // If skill not found or invalid, we're done (error message already in prepared.content)
+              return;
+            }
+
+            // 3. Execute bash commands asynchronously
+            const result = await this.skillManager.executeSkill({
+              skill_name: skill.name,
+              args,
+            });
+
+            // 4. Update the message with final content
+            this.messageManager.updateUserMessage(messageId, {
               customCommandContent: result.content,
             });
 
-            // Trigger AI response
+            // 5. Trigger AI response
             await this.aiManager.sendAIMessage({
               model: skill.model,
               allowedRules: result.allowedTools,
@@ -358,6 +376,15 @@ export class SlashCommandManager {
     args?: string,
   ): Promise<void> {
     try {
+      // Add custom command message immediately to show the command being executed
+      const originalInput = args
+        ? `/${commandName} ${args}`
+        : `/${commandName}`;
+      const messageId = this.messageManager.addUserMessage({
+        content: originalInput,
+        customCommandContent: content, // Initial content with bash placeholders
+      });
+
       // Parse bash commands from the content
       const { commands, processedContent } = parseBashCommands(content);
 
@@ -371,12 +398,8 @@ export class SlashCommandManager {
         );
       }
 
-      // Add custom command message to show the command being executed
-      const originalInput = args
-        ? `/${commandName} ${args}`
-        : `/${commandName}`;
-      this.messageManager.addUserMessage({
-        content: originalInput,
+      // Update the message with final content
+      this.messageManager.updateUserMessage(messageId, {
         customCommandContent: finalContent,
       });
 

package/src/managers/subagentManager.ts

@@ -1,4 +1,7 @@
 import { randomUUID } from "crypto";
+import * as os from "os";
+import * as fs from "fs";
+import * as path from "path";
 import type { SubagentConfiguration } from "../utils/subagentParser.js";
 import type { Message, Usage } from "../types/index.js";
 import { AIManager } from "./aiManager.js";
@@ -70,6 +73,7 @@ export interface SubagentInstance {
   backgroundTaskId?: string; // ID of the background task if transitioned
   onUpdate?: () => void; // Optional callback for real-time updates
   model?: string; // Optional model override
+  logStream?: fs.WriteStream; // Optional log stream for background tasks
 }
 
 export interface SubagentManagerOptions {
@@ -274,6 +278,11 @@ export class SubagentManager {
         const taskId = backgroundTaskManager.generateId();
         const startTime = Date.now();
 
+        // Create log file
+        const logPath = path.join(os.tmpdir(), `wave-subagent-${taskId}.log`);
+        const logStream = fs.createWriteStream(logPath, { flags: "a" });
+        instance.logStream = logStream;
+
         backgroundTaskManager.addTask({
           id: taskId,
           type: "subagent",
@@ -282,8 +291,10 @@ export class SubagentManager {
           description: instance.description,
           stdout: "",
           stderr: "",
+          outputPath: logPath,
           subagentId: instance.subagentId,
           onStop: () => {
+            instance.logStream?.end();
             instance.aiManager.abortAIMessage();
             this.cleanupInstance(instance.subagentId);
           },
@@ -345,6 +356,11 @@ export class SubagentManager {
     const taskId = backgroundTaskManager.generateId();
     const startTime = Date.now();
 
+    // Create log file
+    const logPath = path.join(os.tmpdir(), `wave-subagent-${taskId}.log`);
+    const logStream = fs.createWriteStream(logPath, { flags: "a" });
+    instance.logStream = logStream;
+
     backgroundTaskManager.addTask({
       id: taskId,
       type: "subagent",
@@ -353,8 +369,10 @@ export class SubagentManager {
       description: instance.description,
       stdout: "",
       stderr: "",
+      outputPath: logPath,
       subagentId: instance.subagentId,
       onStop: () => {
+        instance.logStream?.end();
         instance.aiManager.abortAIMessage();
         this.cleanupInstance(instance.subagentId);
       },
@@ -446,6 +464,7 @@ export class SubagentManager {
 
       // If this was transitioned to background, update the background task
       if (instance.backgroundTaskId && backgroundTaskManager) {
+        instance.logStream?.end();
         const task = backgroundTaskManager.getTask(instance.backgroundTaskId);
         if (task) {
           task.status = "completed";
@@ -465,6 +484,7 @@ export class SubagentManager {
 
       // If this was transitioned to background, update the background task with error
       if (instance.backgroundTaskId && backgroundTaskManager) {
+        instance.logStream?.end();
         const task = backgroundTaskManager.getTask(instance.backgroundTaskId);
         if (task) {
           task.status = "failed";
@@ -599,6 +619,17 @@ export class SubagentManager {
               instance.lastTools.shift();
             }
             instance.onUpdate?.();
+
+            // Log tool execution to file
+            if (instance.logStream) {
+              const compactParams = (params.parameters || "{}").substring(
+                0,
+                100,
+              );
+              instance.logStream.write(
+                `[${new Date().toISOString()}] Running tool: ${params.name} with params: ${compactParams}${compactParams.length >= 100 ? "..." : ""}\n`,
+              );
+            }
           }
         }
 

package/src/services/MarketplaceService.ts

@@ -243,6 +243,7 @@ export class MarketplaceService {
           ? { source: "git", url: urlOrRepo, ref }
           : { source: "github", repo: urlOrRepo, ref },
         autoUpdate: false,
+        lastUpdated: new Date().toISOString(),
       };
     } else {
       // Local directory format
@@ -260,6 +261,7 @@ export class MarketplaceService {
         name: manifest.name,
         source: { source: "directory", path: absolutePath },
         autoUpdate: false,
+        lastUpdated: new Date().toISOString(),
       };
     }
 
@@ -363,6 +365,8 @@ export class MarketplaceService {
           this.getMarketplacePath(marketplace),
         );
 
+        marketplace.lastUpdated = new Date().toISOString();
+
         if (options?.updatePlugins) {
           const installedRegistry = await this.getInstalledPlugins();
           const pluginsToUpdate = installedRegistry.plugins.filter(
@@ -414,6 +418,8 @@ export class MarketplaceService {
         `Some marketplaces failed to update:\n${errors.join("\n")}`,
       );
     }
+
+    await this.saveKnownMarketplaces(registry);
   }
 
   /**

package/src/services/hook.ts

@@ -155,6 +155,14 @@ export async function executeCommand(
       },
     });
 
+    // Handle stdin errors (e.g. EPIPE if the process closes stdin early)
+    if (childProcess.stdin) {
+      childProcess.stdin.on("error", () => {
+        // Ignore stdin errors as they just mean the process closed stdin early
+        // or doesn't want to read from it.
+      });
+    }
+
     // Set up timeout
     const timeoutHandle = setTimeout(() => {
       timedOut = true;
@@ -173,6 +181,9 @@ export async function executeCommand(
       childProcess.stdout.on("data", (data: Buffer) => {
         stdout += data.toString();
       });
+      childProcess.stdout.on("error", () => {
+        // Ignore stdout errors
+      });
     }
 
     // Handle stderr
@@ -180,17 +191,20 @@ export async function executeCommand(
       childProcess.stderr.on("data", (data: Buffer) => {
         stderr += data.toString();
       });
+      childProcess.stderr.on("error", () => {
+        // Ignore stderr errors
+      });
     }
 
     // Send JSON input to stdin if we have prepared it
-    if (childProcess.stdin && jsonInput) {
+    if (childProcess.stdin && childProcess.stdin.writable && jsonInput) {
       try {
         childProcess.stdin.write(jsonInput);
         childProcess.stdin.end();
       } catch {
         // Continue execution even if JSON input fails
       }
-    } else if (childProcess.stdin) {
+    } else if (childProcess.stdin && childProcess.stdin.writable) {
       childProcess.stdin.end();
     }
 

package/src/tools/agentTool.ts

@@ -182,10 +182,14 @@ When using the Agent tool, you must specify a subagent_type parameter to select
               id: instance.subagentId,
               backgroundHandler: async () => {
                 isBackgrounded = true;
-                await subagentManager.backgroundInstance(instance.subagentId);
+                const taskId = await subagentManager.backgroundInstance(
+                  instance.subagentId,
+                );
+                const task = context.backgroundTaskManager?.getTask(taskId);
+                const outputPath = task?.outputPath;
                 resolve({
                   success: true,
-                  content: "Agent backgrounded",
+                  content: `Agent backgrounded with ID: ${taskId}.${outputPath ? ` Real-time output: ${outputPath}` : ""}`,
                   shortResult: "Agent backgrounded",
                   isManuallyBackgrounded: true,
                 });
@@ -206,9 +210,11 @@ 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;
               resolve({
                 success: true,
-                content: `Agent started in background with ID: ${result}`,
+                content: `Agent started in background with ID: ${result}.${outputPath ? ` Real-time output: ${outputPath}` : ""}`,
                 shortResult: `Agent started in background: ${result}`,
               });
               return;

package/src/tools/bashTool.ts

@@ -177,9 +177,11 @@ Usage notes:
       }
 
       const { id: taskId } = backgroundTaskManager.startShell(command, timeout);
+      const task = backgroundTaskManager.getTask(taskId);
+      const outputPath = task?.outputPath;
       return {
         success: true,
-        content: `Command started in background with ID: ${taskId}. Use TaskOutput tool with task_id="${taskId}" to monitor output.`,
+        content: `Command started in background with ID: ${taskId}.${outputPath ? ` Real-time output: ${outputPath}` : ` Use TaskOutput tool with task_id="${taskId}" to monitor output.`}`,
         shortResult: `Background process ${taskId} started`,
       };
     }
@@ -220,9 +222,11 @@ Usage notes:
                 outputBuffer,
                 errorBuffer,
               );
+              const task = backgroundTaskManager.getTask(taskId);
+              const outputPath = task?.outputPath;
               resolve({
                 success: true,
-                content: `Command moved to background with ID: ${taskId}.`,
+                content: `Command moved to background with ID: ${taskId}.${outputPath ? ` Real-time output: ${outputPath}` : ""}`,
                 shortResult: `Process ${taskId} backgrounded`,
                 isManuallyBackgrounded: true,
               });