wave-agent-sdk 1.0.4 → 1.0.6

package/src/services/fileWatcher.ts

@@ -1,319 +0,0 @@
-/**
- * File Watcher Service
- *
- * Provides robust cross-platform file watching using Chokidar library.
- * Handles file watching with debouncing, error recovery, and graceful fallbacks.
- */
-
-import * as chokidar from "chokidar";
-import { EventEmitter } from "events";
-import type { Logger } from "../types/index.js";
-
-export interface FileWatchEvent {
-  type: "change" | "create" | "delete" | "rename";
-  path: string;
-  timestamp: number;
-  size?: number;
-}
-
-export interface FileWatcherConfig {
-  stabilityThreshold: number; // Chokidar awaitWriteFinish delay (ms)
-  pollInterval: number; // Chokidar polling interval (ms)
-  maxRetries: number; // Default: 3
-  fallbackPolling: boolean; // Default: false
-  ignoreTempFiles: boolean; // Default: true
-  depth: number; // default: 5
-  ignored: string[]; // default: ['**/node_modules/**', '**/.git/**', '**/*.swp', '**/*~']
-}
-
-export interface FileWatcherStatus {
-  isActive: boolean;
-  path: string;
-  method: "native" | "polling" | "failed";
-  errorCount: number;
-  lastError?: string;
-  lastEvent?: FileWatchEvent;
-}
-
-interface FileWatcherEntry {
-  path: string;
-  watcher: chokidar.FSWatcher | null;
-  isActive: boolean;
-  lastEvent: number;
-  errorCount: number;
-  lastError?: string;
-  callbacks: Set<(event: FileWatchEvent) => void>;
-  config: FileWatcherConfig;
-}
-
-export class FileWatcherService extends EventEmitter {
-  private watchers: Map<string, FileWatcherEntry> = new Map();
-  private globalWatcher: chokidar.FSWatcher | null = null;
-  private defaultConfig: FileWatcherConfig;
-  private logger?: Logger;
-
-  constructor(logger?: Logger, config?: Partial<FileWatcherConfig>) {
-    super();
-    this.logger = logger;
-    this.defaultConfig = {
-      stabilityThreshold: 300,
-      pollInterval: 100,
-      maxRetries: 3,
-      fallbackPolling: false,
-      ignoreTempFiles: true,
-      depth: 5,
-      ignored: ["**/node_modules/**", "**/.git/**", "**/*.swp", "**/*~"],
-      ...config,
-    };
-  }
-
-  /**
-   * Start watching a file
-   * Maps to FR-010: Handle file deletion, creation, and modification
-   */
-  async watchFile(
-    path: string,
-    callback: (event: FileWatchEvent) => void,
-  ): Promise<void> {
-    try {
-      if (this.watchers.has(path)) {
-        // Add callback to existing watcher
-        const entry = this.watchers.get(path)!;
-        entry.callbacks.add(callback);
-        return;
-      }
-
-      // Create new watcher entry
-      const entry: FileWatcherEntry = {
-        path,
-        watcher: null,
-        isActive: false,
-        lastEvent: Date.now(),
-        errorCount: 0,
-        lastError: undefined,
-        callbacks: new Set([callback]),
-        config: { ...this.defaultConfig },
-      };
-
-      this.watchers.set(path, entry);
-      await this.initializeWatcher(entry);
-    } catch (error) {
-      this.logger?.error(
-        `FileWatcher: Failed to watch file ${path}: ${(error as Error).message}`,
-      );
-      throw error;
-    }
-  }
-
-  /**
-   * Stop watching a file
-   * Resource cleanup
-   */
-  async unwatchFile(path: string): Promise<void> {
-    const entry = this.watchers.get(path);
-    if (!entry) return;
-
-    try {
-      if (entry.watcher) {
-        entry.watcher.unwatch(path);
-      }
-
-      this.watchers.delete(path);
-    } catch (error) {
-      this.logger?.warn(
-        `FileWatcher: Error unwatching file ${path}: ${(error as Error).message}`,
-      );
-    }
-  }
-
-  /**
-   * Get watcher status
-   * Maps to FR-012: Handle watcher initialization failures
-   */
-  getWatcherStatus(path: string): FileWatcherStatus | null {
-    const entry = this.watchers.get(path);
-    if (!entry) return null;
-
-    return {
-      isActive: entry.isActive,
-      path: entry.path,
-      method:
-        entry.errorCount > 0
-          ? "failed"
-          : entry.config.fallbackPolling
-            ? "polling"
-            : "native",
-      errorCount: entry.errorCount,
-      lastError: entry.lastError,
-      lastEvent:
-        entry.lastEvent > 0
-          ? {
-              type: "change",
-              path: entry.path,
-              timestamp: entry.lastEvent,
-            }
-          : undefined,
-    };
-  }
-
-  /**
-   * Get all watcher statuses
-   * For monitoring and debugging
-   */
-  getAllWatcherStatuses(): FileWatcherStatus[] {
-    return Array.from(this.watchers.keys())
-      .map((path) => this.getWatcherStatus(path))
-      .filter((status): status is FileWatcherStatus => status !== null);
-  }
-
-  /**
-   * Cleanup all watchers
-   */
-  async cleanup(): Promise<void> {
-    const paths = Array.from(this.watchers.keys());
-    for (const path of paths) {
-      await this.unwatchFile(path);
-    }
-
-    if (this.globalWatcher) {
-      const watcher = this.globalWatcher;
-      this.globalWatcher = null;
-      await watcher.close();
-    }
-  }
-
-  private async initializeWatcher(entry: FileWatcherEntry): Promise<void> {
-    try {
-      // Initialize global watcher if needed
-      if (!this.globalWatcher) {
-        this.globalWatcher = chokidar.watch([], {
-          persistent: true,
-          ignoreInitial: true,
-          depth: entry.config.depth,
-          ignored: entry.config.ignored,
-          awaitWriteFinish: {
-            stabilityThreshold: entry.config.stabilityThreshold,
-            pollInterval: entry.config.pollInterval,
-          },
-          usePolling: entry.config.fallbackPolling,
-          interval: entry.config.pollInterval,
-        });
-
-        // Unref the global watcher to allow natural exit if it's the only thing left
-        // (chokidar watchers keep the process alive by default)
-        // Note: some platforms might need additional handling
-        const watcher = this.globalWatcher as unknown as { unref?: () => void };
-        if (watcher.unref) {
-          watcher.unref();
-        }
-
-        this.setupGlobalWatcherEvents();
-      }
-
-      // Add path to global watcher
-      this.globalWatcher.add(entry.path);
-      entry.watcher = this.globalWatcher;
-      entry.isActive = true;
-      entry.errorCount = 0;
-    } catch (error) {
-      entry.errorCount++;
-      entry.isActive = false;
-      entry.lastError = (error as Error).message;
-
-      this.logger?.error(
-        `FileWatcher: Failed to initialize watcher for ${entry.path}: ${(error as Error).message}`,
-      );
-
-      // Try fallback polling if not already using it
-      if (
-        !entry.config.fallbackPolling &&
-        entry.errorCount < entry.config.maxRetries
-      ) {
-        entry.config.fallbackPolling = true;
-        await this.initializeWatcher(entry);
-      } else {
-        throw error;
-      }
-    }
-  }
-
-  private setupGlobalWatcherEvents(): void {
-    if (!this.globalWatcher) return;
-
-    this.globalWatcher.on(
-      "change",
-      (filePath: string, stats?: { size?: number }) => {
-        this.handleFileEvent("change", filePath, stats);
-      },
-    );
-
-    this.globalWatcher.on(
-      "add",
-      (filePath: string, stats?: { size?: number }) => {
-        this.handleFileEvent("create", filePath, stats);
-      },
-    );
-
-    this.globalWatcher.on("unlink", (filePath: string) => {
-      this.handleFileEvent("delete", filePath);
-    });
-
-    this.globalWatcher.on("addDir", (dirPath: string) => {
-      this.handleFileEvent("create", dirPath);
-    });
-
-    this.globalWatcher.on("unlinkDir", (dirPath: string) => {
-      this.handleFileEvent("delete", dirPath);
-    });
-
-    this.globalWatcher.on("error", (err: unknown) => {
-      const error = err instanceof Error ? err : new Error(String(err));
-      const isEMFILE = (error as NodeJS.ErrnoException).code === "EMFILE";
-      if (isEMFILE) {
-        this.logger?.warn(
-          "FileWatcher: Too many open files (EMFILE). " +
-            "Consider increasing the limit: `ulimit -n 10240` (macOS) or `ulimit -n 65536` (Linux).",
-        );
-      } else {
-        this.logger?.error(`FileWatcher: File watcher error: ${error.message}`);
-      }
-      this.emit("watcherError", error);
-    });
-  }
-
-  private handleFileEvent(
-    type: FileWatchEvent["type"],
-    filePath: string,
-    stats?: { size?: number },
-  ): void {
-    const event: FileWatchEvent = {
-      type,
-      path: filePath,
-      timestamp: Date.now(),
-      size: stats?.size,
-    };
-
-    // Notify all watchers that match the path or are parents of the path
-    for (const [watchedPath, entry] of this.watchers.entries()) {
-      const normalizedFilePath = filePath.replace(/\\/g, "/");
-      const normalizedWatchedPath = watchedPath.replace(/\\/g, "/");
-      if (
-        normalizedFilePath === normalizedWatchedPath ||
-        normalizedFilePath.startsWith(normalizedWatchedPath + "/")
-      ) {
-        entry.lastEvent = event.timestamp;
-
-        // Notify all callbacks for this watcher
-        for (const callback of entry.callbacks) {
-          try {
-            callback(event);
-          } catch (error) {
-            this.logger?.error(
-              `FileWatcher: Error in file watch callback for ${watchedPath} (event on ${filePath}): ${(error as Error).message}`,
-            );
-          }
-        }
-      }
-    }
-  }
-}

package/src/services/hook.ts

@@ -1,348 +0,0 @@
-/**
- * Hook Execution Services
- *
- * Provides hook command execution functionality and hook-specific configuration loading.
- * This module focuses on hook execution while delegating general Wave configuration
- * management to ConfigurationService.
- */
-
-import { spawn, type ChildProcess } from "child_process";
-import {
-  type HookExecutionContext,
-  type HookExecutionResult,
-  type HookExecutionOptions,
-  type ExtendedHookExecutionContext,
-  type HookJsonInput,
-} from "../types/hooks.js";
-import { generateSessionFilePath } from "./session.js";
-
-// =============================================================================
-// Hook Execution Functions
-// =============================================================================
-
-/**
- * Build JSON input data for hook stdin
- */
-async function buildHookJsonInput(
-  context: ExtendedHookExecutionContext,
-): Promise<HookJsonInput> {
-  const workdir = context.cwd || context.projectDir || process.cwd();
-
-  let transcriptPath = context.transcriptPath;
-  if (!transcriptPath && context.sessionId) {
-    try {
-      transcriptPath = await generateSessionFilePath(
-        context.sessionId,
-        workdir,
-      );
-    } catch {
-      transcriptPath = "";
-    }
-  }
-
-  const jsonInput: HookJsonInput = {
-    session_id: context.sessionId || "unknown",
-    transcript_path: transcriptPath || "",
-    cwd: workdir,
-    hook_event_name: context.event,
-  };
-
-  // Add optional fields based on event type
-  if (
-    context.event === "PreToolUse" ||
-    context.event === "PostToolUse" ||
-    context.event === "PermissionRequest"
-  ) {
-    if (context.toolName) {
-      jsonInput.tool_name = context.toolName;
-    }
-    if (context.toolInput !== undefined) {
-      jsonInput.tool_input = context.toolInput;
-    }
-  }
-
-  if (context.event === "PostToolUse" && context.toolResponse !== undefined) {
-    jsonInput.tool_response = context.toolResponse;
-  }
-
-  if (
-    context.event === "UserPromptSubmit" &&
-    context.userPrompt !== undefined
-  ) {
-    jsonInput.user_prompt = context.userPrompt;
-  }
-
-  // Add plan_file_path if present
-  if (context.planFilePath !== undefined) {
-    jsonInput.plan_file_path = context.planFilePath;
-  }
-
-  // Add subagent_type if present
-  if (context.subagentType !== undefined) {
-    jsonInput.subagent_type = context.subagentType;
-  }
-
-  // Add name field for WorktreeCreate events
-  if (context.event === "WorktreeCreate") {
-    if (context.worktreeName !== undefined) {
-      jsonInput.name = context.worktreeName;
-    }
-  }
-
-  // Add worktree_path field for WorktreeRemove events
-  if (context.event === "WorktreeRemove") {
-    if (context.worktreePath !== undefined) {
-      jsonInput.worktree_path = context.worktreePath;
-    }
-  }
-
-  // Add SessionStart-specific fields
-  if (context.event === "SessionStart") {
-    if (context.source !== undefined) {
-      jsonInput.source = context.source;
-    }
-    if (context.agentType !== undefined) {
-      jsonInput.agent_type = context.agentType;
-    }
-  }
-
-  // Add SessionEnd-specific fields
-  if (context.event === "SessionEnd") {
-    if (context.endSource !== undefined) {
-      jsonInput.end_source = context.endSource;
-    }
-  }
-
-  // Add background_tasks and session_crons for Stop events only (not SubagentStop).
-  // Fields are always present for Stop (empty arrays when nothing in flight).
-  if (context.event === "Stop") {
-    jsonInput.background_tasks = context.backgroundTasks ?? [];
-    jsonInput.session_crons = context.sessionCrons ?? [];
-  }
-
-  // Add last_assistant_message for Stop and SubagentStop events.
-  // Omitted when undefined (no text content in last assistant message).
-  if (
-    (context.event === "Stop" || context.event === "SubagentStop") &&
-    context.lastAssistantMessage !== undefined
-  ) {
-    jsonInput.last_assistant_message = context.lastAssistantMessage;
-  }
-
-  return jsonInput;
-}
-
-/**
- * Execute a single hook command
- */
-export async function executeCommand(
-  command: string,
-  context: HookExecutionContext | ExtendedHookExecutionContext,
-  options?: HookExecutionOptions,
-): Promise<HookExecutionResult> {
-  const defaultTimeout = 600000; // 10 minutes
-  const maxTimeout = 600000; // 10 minutes
-  const skipExecution =
-    process.env.NODE_ENV === "test" &&
-    process.env.TEST_HOOK_EXECUTION !== "true";
-
-  const startTime = Date.now();
-  const timeout = Math.min(options?.timeout ?? defaultTimeout, maxTimeout);
-
-  // Return mock result if execution is skipped
-  if (skipExecution) {
-    return {
-      success: true,
-      exitCode: 0,
-      stdout: "",
-      stderr: "",
-      duration: 0,
-      timedOut: false,
-    };
-  }
-
-  // Prepare JSON input for hooks that need it
-  let jsonInput: string | null = null;
-  if ("sessionId" in context) {
-    try {
-      const hookJsonInput = await buildHookJsonInput(context);
-      jsonInput = JSON.stringify(hookJsonInput, null, 2);
-    } catch {
-      // Continue execution even if JSON input preparation fails
-    }
-  }
-
-  return new Promise((resolve) => {
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-
-    // Parse command for shell execution
-    const isWindows = process.platform === "win32";
-    const shell = isWindows ? "cmd.exe" : "/bin/sh";
-    const shellFlag = isWindows ? "/c" : "-c";
-
-    const childProcess: ChildProcess = spawn(shell, [shellFlag, command], {
-      stdio: ["pipe", "pipe", "pipe"],
-      cwd: context.projectDir,
-      env: {
-        ...process.env, // Environment variables from process.env
-        ...("env" in context ? context.env || {} : {}), // Additional environment variables from configuration (if ExtendedHookExecutionContext)
-        HOOK_EVENT: context.event,
-        HOOK_TOOL_NAME: context.toolName || "",
-        WAVE_PROJECT_DIR: context.projectDir,
-      },
-    });
-
-    // 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
-    let forceKillTimeoutHandle: NodeJS.Timeout | undefined;
-    const timeoutHandle = setTimeout(() => {
-      timedOut = true;
-      childProcess.kill("SIGTERM");
-
-      // Force kill after additional delay
-      forceKillTimeoutHandle = setTimeout(() => {
-        if (!childProcess.killed) {
-          childProcess.kill("SIGKILL");
-        }
-      }, 2000);
-    }, timeout);
-
-    // Handle stdout
-    if (childProcess.stdout) {
-      childProcess.stdout.on("data", (data: Buffer) => {
-        stdout += data.toString();
-      });
-      childProcess.stdout.on("error", () => {
-        // Ignore stdout errors
-      });
-    }
-
-    // Handle stderr
-    if (childProcess.stderr) {
-      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 && childProcess.stdin.writable && jsonInput) {
-      try {
-        childProcess.stdin.write(jsonInput);
-        childProcess.stdin.end();
-      } catch {
-        // Continue execution even if JSON input fails
-      }
-    } else if (childProcess.stdin && childProcess.stdin.writable) {
-      childProcess.stdin.end();
-    }
-
-    // Handle process completion
-    childProcess.on("close", (code: number | null) => {
-      clearTimeout(timeoutHandle);
-      if (forceKillTimeoutHandle) clearTimeout(forceKillTimeoutHandle);
-      const duration = Date.now() - startTime;
-
-      resolve({
-        success: !timedOut && (code === 0 || code === null),
-        exitCode: code || 0,
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        duration,
-        timedOut,
-      });
-    });
-
-    // Handle process errors
-    childProcess.on("error", (error: Error) => {
-      clearTimeout(timeoutHandle);
-      if (forceKillTimeoutHandle) clearTimeout(forceKillTimeoutHandle);
-      const duration = Date.now() - startTime;
-
-      resolve({
-        success: false,
-        exitCode: 1,
-        stdout: stdout.trim(),
-        stderr: error.message,
-        duration,
-        timedOut,
-      });
-    });
-  });
-}
-
-/**
- * Execute multiple commands in sequence
- */
-export async function executeCommands(
-  commands: string[],
-  context: HookExecutionContext | ExtendedHookExecutionContext,
-  options?: HookExecutionOptions,
-): Promise<HookExecutionResult[]> {
-  const results: HookExecutionResult[] = [];
-
-  for (const command of commands) {
-    const result = await executeCommand(command, context, options);
-    results.push(result);
-
-    // Stop on first failure unless continueOnFailure is set
-    if (!result.success && !options?.continueOnFailure) {
-      break;
-    }
-  }
-
-  return results;
-}
-
-/**
- * Execute a CwdChanged hook
- */
-export async function executeCwdChangedHooks(
-  oldCwd: string,
-  newCwd: string,
-  context: ExtendedHookExecutionContext,
-): Promise<HookExecutionResult[]> {
-  // CwdChanged hooks are executed through HookManager.executeCwdChangedHooks()
-  void context;
-  void oldCwd;
-  void newCwd;
-  return [];
-}
-
-/**
- * Validate command safety (basic checks)
- */
-export function isCommandSafe(command: string): boolean {
-  const trimmed = command.trim();
-
-  // Empty commands are safe (no-op)
-  if (!trimmed) {
-    return true;
-  }
-
-  // Check for obviously dangerous patterns
-  const dangerousPatterns = [
-    /rm\s+-rf\s+\//, // rm -rf /
-    /sudo\s+rm/, // sudo rm
-    />\s*\/dev\/sd[a-z]/, // writing to disk devices
-    /dd\s+if=.*of=\/dev/, // dd to devices
-    /mkfs/, // filesystem creation
-    /fdisk/, // disk partitioning
-    /format\s+[a-z]:/, // Windows format command
-  ];
-
-  return !dangerousPatterns.some((pattern) =>
-    pattern.test(trimmed.toLowerCase()),
-  );
-}