wave-agent-sdk 0.0.1

package/src/services/session.ts

@@ -0,0 +1,265 @@
+import { promises as fs } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import type { Message } from "../types.js";
+
+export interface SessionData {
+  id: string;
+  timestamp: string;
+  version: string;
+  messages: Message[];
+  metadata: {
+    workdir: string;
+    startedAt: string;
+    lastActiveAt: string;
+    latestTotalTokens: number;
+  };
+}
+
+export interface SessionMetadata {
+  id: string;
+  timestamp: string;
+  workdir: string;
+  startedAt: string;
+  lastActiveAt: string;
+  latestTotalTokens: number;
+}
+
+// Constants
+const SESSION_DIR = join(homedir(), ".wave", "sessions");
+const VERSION = "1.0.0";
+const MAX_SESSION_AGE_DAYS = 30;
+
+/**
+ * Ensure session directory exists
+ */
+async function ensureSessionDir(): Promise<void> {
+  try {
+    await fs.mkdir(SESSION_DIR, { recursive: true });
+  } catch (error) {
+    throw new Error(`Failed to create session directory: ${error}`);
+  }
+}
+
+/**
+ * Generate session file path
+ */
+export function getSessionFilePath(sessionId: string): string {
+  const shortId = sessionId.split("_")[2] || sessionId.slice(-8);
+  return join(SESSION_DIR, `session_${shortId}.json`);
+}
+
+/**
+ * Filter out diff blocks from messages to avoid saving unimportant data
+ */
+function filterDiffBlocks(messages: Message[]): Message[] {
+  return messages
+    .map((message) => ({
+      ...message,
+      blocks: message.blocks.filter((block) => block.type !== "diff"),
+    }))
+    .filter((message) => message.blocks.length > 0);
+}
+
+/**
+ * Save session data
+ */
+export async function saveSession(
+  sessionId: string,
+  messages: Message[],
+  workdir: string,
+  latestTotalTokens: number = 0,
+  startedAt?: string,
+): Promise<void> {
+  // Do not save session files in test environment
+  if (process.env.NODE_ENV === "test") {
+    return;
+  }
+
+  await ensureSessionDir();
+
+  // Filter out diff blocks before saving
+  const filteredMessages = filterDiffBlocks(messages);
+
+  const now = new Date().toISOString();
+  const sessionData: SessionData = {
+    id: sessionId,
+    timestamp: now,
+    version: VERSION,
+    messages: filteredMessages,
+    metadata: {
+      workdir: workdir,
+      startedAt: startedAt || now,
+      lastActiveAt: now,
+      latestTotalTokens,
+    },
+  };
+
+  const filePath = getSessionFilePath(sessionId);
+  try {
+    await fs.writeFile(filePath, JSON.stringify(sessionData, null, 2), "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to save session ${sessionId}: ${error}`);
+  }
+}
+
+/**
+ * Load session data
+ */
+export async function loadSession(
+  sessionId: string,
+): Promise<SessionData | null> {
+  const filePath = getSessionFilePath(sessionId);
+
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    const sessionData = JSON.parse(content) as SessionData;
+
+    // Validate session data format
+    if (!sessionData.id || !sessionData.messages || !sessionData.metadata) {
+      throw new Error("Invalid session data format");
+    }
+
+    return sessionData;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return null; // Session file does not exist
+    }
+    throw new Error(`Failed to load session ${sessionId}: ${error}`);
+  }
+}
+
+/**
+ * Get most recent session
+ */
+export async function getLatestSession(
+  workdir: string,
+): Promise<SessionData | null> {
+  const sessions = await listSessions(workdir);
+  if (sessions.length === 0) {
+    return null;
+  }
+
+  // Sort by last active time, return the latest
+  const latestSession = sessions.sort(
+    (a, b) =>
+      new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime(),
+  )[0];
+
+  return loadSession(latestSession.id);
+}
+
+/**
+ * List all sessions
+ */
+export async function listSessions(
+  workdir: string,
+  includeAllWorkdirs = false,
+): Promise<SessionMetadata[]> {
+  try {
+    await ensureSessionDir();
+    const files = await fs.readdir(SESSION_DIR);
+
+    const sessions: SessionMetadata[] = [];
+
+    for (const file of files) {
+      if (!file.startsWith("session_") || !file.endsWith(".json")) {
+        continue;
+      }
+
+      try {
+        const filePath = join(SESSION_DIR, file);
+        const content = await fs.readFile(filePath, "utf-8");
+        const sessionData = JSON.parse(content) as SessionData;
+
+        // Only return sessions for the current working directory, unless includeAllWorkdirs is true
+        if (!includeAllWorkdirs && sessionData.metadata.workdir !== workdir) {
+          continue;
+        }
+
+        sessions.push({
+          id: sessionData.id,
+          timestamp: sessionData.timestamp,
+          workdir: sessionData.metadata.workdir,
+          startedAt: sessionData.metadata.startedAt,
+          lastActiveAt: sessionData.metadata.lastActiveAt,
+          latestTotalTokens: sessionData.metadata.latestTotalTokens,
+        });
+      } catch {
+        // Ignore corrupted session files
+        console.warn(`Skipping corrupted session file: ${file}`);
+      }
+    }
+
+    return sessions.sort(
+      (a, b) =>
+        new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime(),
+    );
+  } catch (error) {
+    throw new Error(`Failed to list sessions: ${error}`);
+  }
+}
+
+/**
+ * Delete session
+ */
+export async function deleteSession(sessionId: string): Promise<boolean> {
+  const filePath = getSessionFilePath(sessionId);
+
+  try {
+    await fs.unlink(filePath);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return false; // File does not exist
+    }
+    throw new Error(`Failed to delete session ${sessionId}: ${error}`);
+  }
+}
+
+/**
+ * Clean up expired sessions
+ */
+export async function cleanupExpiredSessions(workdir: string): Promise<number> {
+  // Do not perform cleanup operations in test environment
+  if (process.env.NODE_ENV === "test") {
+    return 0;
+  }
+
+  const sessions = await listSessions(workdir, true);
+  const now = new Date();
+  const maxAge = MAX_SESSION_AGE_DAYS * 24 * 60 * 60 * 1000; // Convert to milliseconds
+
+  let deletedCount = 0;
+
+  for (const session of sessions) {
+    const sessionAge = now.getTime() - new Date(session.lastActiveAt).getTime();
+
+    if (sessionAge > maxAge) {
+      try {
+        await deleteSession(session.id);
+        deletedCount++;
+      } catch (error) {
+        console.warn(
+          `Failed to delete expired session ${session.id}: ${error}`,
+        );
+      }
+    }
+  }
+
+  return deletedCount;
+}
+
+/**
+ * Check if session exists
+ */
+export async function sessionExists(sessionId: string): Promise<boolean> {
+  const filePath = getSessionFilePath(sessionId);
+
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/tools/bashTool.ts

@@ -0,0 +1,402 @@
+import { spawn, ChildProcess } from "child_process";
+import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
+
+/**
+ * Bash command execution tool - supports both foreground and background execution
+ */
+export const bashTool: ToolPlugin = {
+  name: "Bash",
+  config: {
+    type: "function",
+    function: {
+      name: "Bash",
+      description:
+        "Executes a given bash command in a persistent shell session with optional timeout, ensuring proper handling and security measures.",
+      parameters: {
+        type: "object",
+        properties: {
+          command: {
+            type: "string",
+            description: "The command to execute",
+          },
+          timeout: {
+            type: "number",
+            description: "Optional timeout in milliseconds (max 600000)",
+          },
+          description: {
+            type: "string",
+            description:
+              "Clear, concise description of what this command does in 5-10 words.",
+          },
+          run_in_background: {
+            type: "boolean",
+            description:
+              "Set to true to run this command in the background. Use BashOutput to read the output later.",
+          },
+        },
+        required: ["command"],
+      },
+    },
+  },
+  execute: async (
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    const command = args.command as string;
+    const runInBackground = args.run_in_background as boolean | undefined;
+    // Set default timeout: 30s for foreground, no timeout for background
+    const timeout =
+      (args.timeout as number | undefined) ??
+      (runInBackground ? undefined : 30000);
+
+    if (!command || typeof command !== "string") {
+      return {
+        success: false,
+        content: "",
+        error: "Command parameter is required and must be a string",
+      };
+    }
+
+    // Validate timeout
+    if (
+      timeout !== undefined &&
+      (typeof timeout !== "number" || timeout < 0 || timeout > 600000)
+    ) {
+      return {
+        success: false,
+        content: "",
+        error: "Timeout must be a number between 0 and 600000 milliseconds",
+      };
+    }
+
+    if (runInBackground) {
+      // Background execution
+      const backgroundBashManager = context?.backgroundBashManager;
+      if (!backgroundBashManager) {
+        return {
+          success: false,
+          content: "",
+          error: "Background bash manager not available",
+        };
+      }
+
+      const shellId = backgroundBashManager.startShell(command, timeout);
+      return {
+        success: true,
+        content: `Command started in background with ID: ${shellId}. Use BashOutput tool with bash_id="${shellId}" to monitor output.`,
+        shortResult: `Background process ${shellId} started`,
+      };
+    }
+
+    // Foreground execution (original behavior)
+    return new Promise((resolve) => {
+      const child: ChildProcess = spawn(command, {
+        shell: true,
+        stdio: "pipe",
+        cwd: context.workdir,
+        env: {
+          ...process.env,
+        },
+      });
+
+      let outputBuffer = "";
+      let errorBuffer = "";
+      let isAborted = false;
+
+      // Set up timeout
+      let timeoutHandle: NodeJS.Timeout | undefined;
+      if (timeout && timeout > 0) {
+        timeoutHandle = setTimeout(() => {
+          if (!isAborted) {
+            handleAbort("Command timed out");
+          }
+        }, timeout);
+      }
+
+      // Handle abort signal
+      const handleAbort = (reason = "Command execution was aborted") => {
+        if (!isAborted) {
+          isAborted = true;
+
+          if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+          }
+
+          // Force terminate child process and its children
+          if (child.pid) {
+            try {
+              // Try graceful termination of process group
+              process.kill(-child.pid, "SIGTERM");
+
+              // Set timeout for force kill
+              setTimeout(() => {
+                if (child.pid && !child.killed) {
+                  try {
+                    process.kill(-child.pid, "SIGKILL");
+                  } catch {
+                    // logger.error("Failed to force kill process:", killError);
+                  }
+                }
+              }, 1000);
+            } catch {
+              // If process group termination fails, try direct child process termination
+              try {
+                child.kill("SIGTERM");
+                setTimeout(() => {
+                  if (!child.killed) {
+                    child.kill("SIGKILL");
+                  }
+                }, 1000);
+              } catch {
+                // logger.error("Failed to kill child process:", directKillError);
+              }
+            }
+          }
+
+          resolve({
+            success: false,
+            content: outputBuffer + (errorBuffer ? "\n" + errorBuffer : ""),
+            error: reason,
+          });
+        }
+      };
+
+      // Handle abort signal from context
+      if (context?.abortSignal) {
+        if (context.abortSignal.aborted) {
+          handleAbort();
+          return;
+        }
+        context.abortSignal.addEventListener("abort", () => handleAbort());
+      }
+
+      child.stdout?.on("data", (data) => {
+        if (!isAborted) {
+          outputBuffer += data.toString();
+        }
+      });
+
+      child.stderr?.on("data", (data) => {
+        if (!isAborted) {
+          errorBuffer += data.toString();
+        }
+      });
+
+      child.on("exit", (code) => {
+        if (!isAborted) {
+          if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+          }
+
+          const exitCode = code ?? 0;
+          const combinedOutput =
+            outputBuffer + (errorBuffer ? "\n" + errorBuffer : "");
+
+          resolve({
+            success: exitCode === 0,
+            content:
+              combinedOutput || `Command executed with exit code: ${exitCode}`,
+            error:
+              exitCode !== 0
+                ? `Command failed with exit code: ${exitCode}`
+                : undefined,
+          });
+        }
+      });
+
+      child.on("error", (error) => {
+        if (!isAborted) {
+          if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+          }
+          resolve({
+            success: false,
+            content: "",
+            error: `Failed to execute command: ${error.message}`,
+          });
+        }
+      });
+    });
+  },
+  formatCompactParams: (params: Record<string, unknown>) => {
+    const command = params.command as string;
+    const runInBackground = params.run_in_background as boolean;
+    return `${command}${runInBackground ? " background" : ""}`;
+  },
+};
+
+/**
+ * BashOutput tool - retrieves output from background bash shells
+ */
+export const bashOutputTool: ToolPlugin = {
+  name: "BashOutput",
+  config: {
+    type: "function",
+    function: {
+      name: "BashOutput",
+      description:
+        "Retrieves output from a running or completed background bash shell",
+      parameters: {
+        type: "object",
+        properties: {
+          bash_id: {
+            type: "string",
+            description:
+              "The ID of the background shell to retrieve output from",
+          },
+          filter: {
+            type: "string",
+            description:
+              "Optional regular expression to filter the output lines. Only lines matching this regex will be included in the result. Any lines that do not match will no longer be available to read.",
+          },
+        },
+        required: ["bash_id"],
+      },
+    },
+  },
+  execute: async (
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    const bashId = args.bash_id as string;
+    const filter = args.filter as string | undefined;
+
+    if (!bashId || typeof bashId !== "string") {
+      return {
+        success: false,
+        content: "",
+        error: "bash_id parameter is required and must be a string",
+      };
+    }
+
+    const backgroundBashManager = context?.backgroundBashManager;
+    if (!backgroundBashManager) {
+      return {
+        success: false,
+        content: "",
+        error: "Background bash manager not available",
+      };
+    }
+
+    const output = backgroundBashManager.getOutput(bashId, filter);
+    if (!output) {
+      return {
+        success: false,
+        content: "",
+        error: `Background shell with ID ${bashId} not found`,
+      };
+    }
+
+    const shell = backgroundBashManager.getShell(bashId);
+    if (!shell) {
+      return {
+        success: false,
+        content: "",
+        error: `Background shell with ID ${bashId} not found`,
+      };
+    }
+
+    let content = "";
+    if (output.stdout) {
+      content += output.stdout;
+    }
+    if (output.stderr) {
+      content += (content ? "\n" : "") + output.stderr;
+    }
+
+    return {
+      success: true,
+      content: content || "No output available",
+      shortResult: `${bashId}: ${output.status}${shell.exitCode !== undefined ? ` (${shell.exitCode})` : ""}`,
+      error: undefined,
+    };
+  },
+  formatCompactParams: (params: Record<string, unknown>) => {
+    const bashId = params.bash_id as string;
+    const filter = params.filter as string | undefined;
+    return filter ? `${bashId} filtered: ${filter}` : bashId;
+  },
+};
+
+/**
+ * KillBash tool - kills a running background bash shell
+ */
+export const killBashTool: ToolPlugin = {
+  name: "KillBash",
+  config: {
+    type: "function",
+    function: {
+      name: "KillBash",
+      description: "Kills a running background bash shell by its ID",
+      parameters: {
+        type: "object",
+        properties: {
+          shell_id: {
+            type: "string",
+            description: "The ID of the background shell to kill",
+          },
+        },
+        required: ["shell_id"],
+      },
+    },
+  },
+  execute: async (
+    args: Record<string, unknown>,
+    context: ToolContext,
+  ): Promise<ToolResult> => {
+    const shellId = args.shell_id as string;
+
+    if (!shellId || typeof shellId !== "string") {
+      return {
+        success: false,
+        content: "",
+        error: "shell_id parameter is required and must be a string",
+      };
+    }
+
+    const backgroundBashManager = context?.backgroundBashManager;
+    if (!backgroundBashManager) {
+      return {
+        success: false,
+        content: "",
+        error: "Background bash manager not available",
+      };
+    }
+
+    const shell = backgroundBashManager.getShell(shellId);
+    if (!shell) {
+      return {
+        success: false,
+        content: "",
+        error: `Background shell with ID ${shellId} not found`,
+      };
+    }
+
+    if (shell.status !== "running") {
+      return {
+        success: false,
+        content: "",
+        error: `Background shell ${shellId} is not running (status: ${shell.status})`,
+      };
+    }
+
+    const killed = backgroundBashManager.killShell(shellId);
+    if (killed) {
+      return {
+        success: true,
+        content: `Background shell ${shellId} has been killed`,
+        shortResult: `Killed ${shellId}`,
+      };
+    } else {
+      return {
+        success: false,
+        content: "",
+        error: `Failed to kill background shell ${shellId}`,
+      };
+    }
+  },
+  formatCompactParams: (params: Record<string, unknown>) => {
+    const shellId = params.shell_id as string;
+    return shellId;
+  },
+};