wave-agent-sdk 0.0.8 → 0.0.10

package/dist/services/configurationService.js

@@ -0,0 +1,585 @@
+/**
+ * Configuration Service
+ *
+ * Centralized service for loading, validating, and managing Wave configuration files.
+ * Replaces distributed configuration logic previously embedded in hook.ts.
+ */
+import { readFileSync, existsSync, promises as fs } from "fs";
+import * as path from "path";
+import { isValidHookEvent } from "../types/hooks.js";
+import { getAllConfigPaths, getExistingConfigPaths, getUserConfigPaths, getProjectConfigPaths, } from "../utils/configPaths.js";
+import { isValidEnvironmentVars, } from "../types/environment.js";
+import { ConfigurationError, CONFIG_ERRORS, } from "../types/index.js";
+import { DEFAULT_TOKEN_LIMIT } from "../utils/constants.js";
+/**
+ * Default ConfigurationService implementation
+ *
+ * Provides centralized configuration loading, validation, and management.
+ * Extracted from distributed logic in hook.ts with improved error handling.
+ */
+export class ConfigurationService {
+    constructor() {
+        this.currentConfiguration = null;
+        this.env = {};
+    }
+    // Core loading operations
+    /**
+     * Load and merge configuration with comprehensive validation
+     */
+    async loadMergedConfiguration(workdir) {
+        try {
+            const userConfigPaths = getUserConfigPaths();
+            const projectConfigPaths = getProjectConfigPaths(workdir);
+            // Use the merged configuration function (this loads user and project configs internally)
+            const mergedConfig = loadMergedWaveConfig(workdir);
+            // Track loading context for better error messages by checking which files exist
+            const loadingContext = [];
+            const userPath = userConfigPaths.find((path) => existsSync(path));
+            if (userPath) {
+                loadingContext.push(`user config from ${userPath}`);
+            }
+            const projectPath = projectConfigPaths.find((path) => existsSync(path));
+            if (projectPath) {
+                loadingContext.push(`project config from ${projectPath}`);
+            }
+            if (!mergedConfig) {
+                const message = loadingContext.length > 0
+                    ? `No valid configuration found despite attempting to load: ${loadingContext.join(", ")}`
+                    : "No configuration files found in user or project directories";
+                return {
+                    configuration: null,
+                    success: true, // No config is valid
+                    warnings: [message],
+                };
+            }
+            // Comprehensive validation
+            const validation = this.validateConfiguration(mergedConfig);
+            if (!validation.isValid) {
+                const sourcePaths = loadingContext.join(" and ");
+                return {
+                    configuration: null,
+                    success: false,
+                    error: `Merged configuration validation failed (sources: ${sourcePaths}): ${validation.errors.join(", ")}`,
+                    warnings: validation.warnings,
+                };
+            }
+            // Success case
+            this.currentConfiguration = mergedConfig;
+            // Set environment variables if present in the merged config
+            if (mergedConfig.env) {
+                this.setEnvironmentVars(mergedConfig.env);
+            }
+            const sourcePaths = loadingContext.join(" and ");
+            return {
+                configuration: mergedConfig,
+                success: true,
+                sourcePath: sourcePaths || "merged configuration",
+                warnings: validation.warnings,
+            };
+        }
+        catch (error) {
+            return {
+                configuration: null,
+                success: false,
+                error: `Failed to load merged configuration from ${workdir}: ${error.message}`,
+                warnings: [],
+            };
+        }
+    }
+    // Validation operations
+    /**
+     * Validate configuration object structure and values
+     */
+    validateConfiguration(config) {
+        const result = {
+            isValid: true,
+            errors: [],
+            warnings: [],
+        };
+        // Validate basic structure
+        if (!config || typeof config !== "object") {
+            result.isValid = false;
+            result.errors.push("Configuration must be a valid object");
+            return result;
+        }
+        // Validate hooks if present
+        if (config.hooks !== undefined) {
+            if (typeof config.hooks !== "object" || config.hooks === null) {
+                result.isValid = false;
+                result.errors.push("Hooks configuration must be an object");
+            }
+            else {
+                for (const [event, eventConfigs] of Object.entries(config.hooks)) {
+                    if (!isValidHookEvent(event)) {
+                        result.warnings.push(`Unknown hook event: ${event}`);
+                        continue;
+                    }
+                    if (!Array.isArray(eventConfigs)) {
+                        result.isValid = false;
+                        result.errors.push(`Hook event '${event}' must be an array`);
+                        continue;
+                    }
+                    // Validate individual hook configurations
+                    for (let i = 0; i < eventConfigs.length; i++) {
+                        const hookConfig = eventConfigs[i];
+                        if (!hookConfig || typeof hookConfig !== "object") {
+                            result.isValid = false;
+                            result.errors.push(`Hook configuration ${i} for event '${event}' must be an object`);
+                        }
+                    }
+                }
+            }
+        }
+        // Validate environment variables if present
+        if (config.env !== undefined) {
+            const envValidation = validateEnvironmentConfig(config.env);
+            if (!envValidation.isValid) {
+                result.isValid = false;
+                result.errors.push(...envValidation.errors);
+            }
+            result.warnings.push(...envValidation.warnings);
+        }
+        // Validate defaultMode if present
+        if (config.defaultMode !== undefined) {
+            if (config.defaultMode !== "default" &&
+                config.defaultMode !== "bypassPermissions" &&
+                config.defaultMode !== "acceptEdits") {
+                result.isValid = false;
+                result.errors.push(`Invalid defaultMode: "${config.defaultMode}". Must be "default", "bypassPermissions" or "acceptEdits"`);
+            }
+        }
+        // Validate permissions if present
+        if (config.permissions !== undefined) {
+            if (typeof config.permissions !== "object" ||
+                config.permissions === null) {
+                result.isValid = false;
+                result.errors.push("Permissions configuration must be an object");
+            }
+            else if (config.permissions.allow !== undefined) {
+                if (!Array.isArray(config.permissions.allow)) {
+                    result.isValid = false;
+                    result.errors.push("Permissions allow must be an array of strings");
+                }
+                else if (!config.permissions.allow.every((rule) => typeof rule === "string")) {
+                    result.isValid = false;
+                    result.errors.push("All permission rules must be strings");
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Validate configuration file without loading
+     */
+    validateConfigurationFile(filePath) {
+        const result = {
+            isValid: true,
+            errors: [],
+            warnings: [],
+        };
+        if (!existsSync(filePath)) {
+            result.isValid = false;
+            result.errors.push(`Configuration file not found: ${filePath}`);
+            return result;
+        }
+        try {
+            const content = readFileSync(filePath, "utf-8");
+            const config = JSON.parse(content);
+            // Use the main validation method
+            const configValidation = this.validateConfiguration(config);
+            result.isValid = configValidation.isValid;
+            result.errors = configValidation.errors;
+            result.warnings = configValidation.warnings;
+        }
+        catch (error) {
+            result.isValid = false;
+            if (error instanceof SyntaxError) {
+                result.errors.push(`Invalid JSON syntax in ${filePath}: ${error.message}`);
+            }
+            else {
+                result.errors.push(`Error reading configuration file ${filePath}: ${error.message}`);
+            }
+        }
+        return result;
+    }
+    // Utility operations
+    /**
+     * Get currently loaded configuration
+     */
+    getCurrentConfiguration() {
+        return this.currentConfiguration;
+    }
+    /**
+     * Set environment variables from configuration
+     * This replaces direct process.env modification
+     */
+    setEnvironmentVars(env) {
+        this.env = { ...env };
+    }
+    /**
+     * Get current environment variables
+     */
+    getEnvironmentVars() {
+        return { ...this.env };
+    }
+    // =============================================================================
+    // Configuration Resolution Methods (merged from configResolver.ts)
+    // =============================================================================
+    /**
+     * Resolves gateway configuration from constructor args and environment
+     * Resolution priority: options > env (from settings.json) > process.env > error
+     * @param apiKey - API key from constructor (optional)
+     * @param baseURL - Base URL from constructor (optional)
+     * @param defaultHeaders - HTTP headers from constructor (optional)
+     * @param fetchOptions - Fetch options from constructor (optional)
+     * @param fetch - Custom fetch implementation from constructor (optional)
+     * @returns Resolved gateway configuration
+     * @throws ConfigurationError if required configuration is missing after fallbacks
+     */
+    resolveGatewayConfig(apiKey, baseURL, defaultHeaders, fetchOptions, fetch) {
+        // Resolve API key: constructor > env (settings.json) > process.env
+        // Note: Explicitly provided empty strings should be treated as invalid, not fall back to env
+        let resolvedApiKey;
+        if (apiKey !== undefined) {
+            resolvedApiKey = apiKey;
+        }
+        else {
+            resolvedApiKey = this.env.AIGW_TOKEN || process.env.AIGW_TOKEN || "";
+        }
+        if (!resolvedApiKey && apiKey === undefined) {
+            throw new ConfigurationError(CONFIG_ERRORS.MISSING_API_KEY, "apiKey", {
+                constructor: apiKey,
+                environment: process.env.AIGW_TOKEN,
+                settings: this.env.AIGW_TOKEN,
+            });
+        }
+        if (resolvedApiKey.trim() === "") {
+            throw new ConfigurationError(CONFIG_ERRORS.EMPTY_API_KEY, "apiKey", resolvedApiKey);
+        }
+        // Resolve base URL: constructor > env (settings.json) > process.env
+        // Note: Explicitly provided empty strings should be treated as invalid, not fall back to env
+        let resolvedBaseURL;
+        if (baseURL !== undefined) {
+            resolvedBaseURL = baseURL;
+        }
+        else {
+            resolvedBaseURL = this.env.AIGW_URL || process.env.AIGW_URL || "";
+        }
+        if (!resolvedBaseURL && baseURL === undefined) {
+            throw new ConfigurationError(CONFIG_ERRORS.MISSING_BASE_URL, "baseURL", {
+                constructor: baseURL,
+                environment: process.env.AIGW_URL,
+                settings: this.env.AIGW_URL,
+            });
+        }
+        if (resolvedBaseURL.trim() === "") {
+            throw new ConfigurationError(CONFIG_ERRORS.EMPTY_BASE_URL, "baseURL", resolvedBaseURL);
+        }
+        return {
+            apiKey: resolvedApiKey,
+            baseURL: resolvedBaseURL,
+            defaultHeaders,
+            fetchOptions,
+            fetch,
+        };
+    }
+    /**
+     * Resolves model configuration with fallbacks
+     * Resolution priority: options > env (from settings.json) > process.env > default
+     * @param agentModel - Agent model from constructor (optional)
+     * @param fastModel - Fast model from constructor (optional)
+     * @returns Resolved model configuration with defaults
+     */
+    resolveModelConfig(agentModel, fastModel) {
+        // Default values as per data-model.md
+        const DEFAULT_AGENT_MODEL = "claude-sonnet-4-20250514";
+        const DEFAULT_FAST_MODEL = "gemini-2.5-flash";
+        // Resolve agent model: constructor > env (settings.json) > process.env > default
+        const resolvedAgentModel = agentModel ||
+            this.env.AIGW_MODEL ||
+            process.env.AIGW_MODEL ||
+            DEFAULT_AGENT_MODEL;
+        // Resolve fast model: constructor > env (settings.json) > process.env > default
+        const resolvedFastModel = fastModel ||
+            this.env.AIGW_FAST_MODEL ||
+            process.env.AIGW_FAST_MODEL ||
+            DEFAULT_FAST_MODEL;
+        return {
+            agentModel: resolvedAgentModel,
+            fastModel: resolvedFastModel,
+        };
+    }
+    /**
+     * Resolves token limit with fallbacks
+     * Resolution priority: options > env (from settings.json) > process.env > default
+     * @param constructorLimit - Token limit from constructor (optional)
+     * @returns Resolved token limit
+     */
+    resolveTokenLimit(constructorLimit) {
+        // If constructor value provided, use it
+        if (constructorLimit !== undefined) {
+            return constructorLimit;
+        }
+        // Try env (settings.json) first, then process.env
+        const envTokenLimit = this.env.TOKEN_LIMIT || process.env.TOKEN_LIMIT;
+        if (envTokenLimit) {
+            const parsed = parseInt(envTokenLimit, 10);
+            if (!isNaN(parsed)) {
+                return parsed;
+            }
+        }
+        // Use default
+        return DEFAULT_TOKEN_LIMIT;
+    }
+    /**
+     * Resolve all configuration file paths
+     */
+    getConfigurationPaths(workdir) {
+        const allPaths = getAllConfigPaths(workdir);
+        const existingPaths = getExistingConfigPaths(workdir);
+        return {
+            userPaths: allPaths.userPaths,
+            projectPaths: allPaths.projectPaths,
+            allPaths: allPaths.allPaths,
+            existingPaths: existingPaths.existingPaths,
+        };
+    }
+    /**
+     * Add a permission rule to the project's settings.local.json
+     */
+    async addAllowedRule(workdir, rule) {
+        const localConfigPath = path.join(workdir, ".wave", "settings.local.json");
+        // Ensure .wave directory exists
+        const waveDir = path.join(workdir, ".wave");
+        if (!existsSync(waveDir)) {
+            await fs.mkdir(waveDir, { recursive: true });
+        }
+        let config = {};
+        if (existsSync(localConfigPath)) {
+            try {
+                const content = await fs.readFile(localConfigPath, "utf-8");
+                config = JSON.parse(content);
+            }
+            catch {
+                // If file is corrupted, start with empty config
+            }
+        }
+        if (!config.permissions) {
+            config.permissions = {};
+        }
+        if (!config.permissions.allow) {
+            config.permissions.allow = [];
+        }
+        if (!config.permissions.allow.includes(rule)) {
+            config.permissions.allow.push(rule);
+            await fs.writeFile(localConfigPath, JSON.stringify(config, null, 2), "utf-8");
+        }
+    }
+}
+// =============================================================================
+// Extracted Configuration Functions
+// =============================================================================
+/**
+ * Validate environment variable configuration
+ */
+export function validateEnvironmentConfig(env, configPath) {
+    const result = {
+        isValid: true,
+        errors: [],
+        warnings: [],
+    };
+    // Check if env is defined
+    if (env === undefined || env === null) {
+        return result; // undefined/null env is valid (means no env vars)
+    }
+    // Validate that env is a Record<string, string>
+    if (!isValidEnvironmentVars(env)) {
+        result.isValid = false;
+        result.errors.push(`Invalid env field format${configPath ? ` in ${configPath}` : ""}. Environment variables must be a Record<string, string>.`);
+        return result;
+    }
+    // Additional validation for environment variable names
+    const envVars = env;
+    for (const [key, value] of Object.entries(envVars)) {
+        // Check for valid environment variable naming convention
+        if (!/^[A-Z_][A-Z0-9_]*$/i.test(key)) {
+            result.warnings.push(`Environment variable '${key}' does not follow standard naming convention (alphanumeric and underscores only).`);
+        }
+        // Check for empty values
+        if (value === "") {
+            result.warnings.push(`Environment variable '${key}' has an empty value.`);
+        }
+        // Check for reserved variable names that might cause conflicts
+        const reservedNames = [
+            "PATH",
+            "HOME",
+            "USER",
+            "PWD",
+            "SHELL",
+            "TERM",
+            "NODE_ENV",
+        ];
+        if (reservedNames.includes(key.toUpperCase())) {
+            result.warnings.push(`Environment variable '${key}' overrides a system variable, which may cause unexpected behavior.`);
+        }
+    }
+    return result;
+}
+/**
+ * Merge environment configurations with project taking precedence over user
+ */
+export function mergeEnvironmentConfig(userEnv, projectEnv, options = {}) {
+    const userVars = userEnv || {};
+    const projectVars = projectEnv || {};
+    const mergedVars = {};
+    const conflicts = [];
+    // Start with user environment variables
+    Object.assign(mergedVars, userVars);
+    // Override with project environment variables and track conflicts
+    for (const [key, projectValue] of Object.entries(projectVars)) {
+        const userValue = userVars[key];
+        if (userValue !== undefined &&
+            userValue !== projectValue &&
+            options.includeConflictWarnings !== false) {
+            // Conflict detected - project value takes precedence
+            conflicts.push({
+                key,
+                userValue,
+                projectValue,
+                resolvedValue: projectValue,
+            });
+        }
+        mergedVars[key] = projectValue;
+    }
+    return {
+        userVars,
+        projectVars,
+        mergedVars,
+        conflicts,
+    };
+}
+/**
+ * Load Wave configuration from a JSON file
+ * Supports both hooks and environment variables with proper validation
+ */
+export function loadWaveConfigFromFile(filePath) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(filePath, "utf-8");
+        const config = JSON.parse(content);
+        // Validate basic structure
+        if (!config || typeof config !== "object") {
+            throw new Error(`Invalid configuration structure in ${filePath}`);
+        }
+        // Validate environment variables if present
+        if (config.env !== undefined) {
+            const envValidation = validateEnvironmentConfig(config.env, filePath);
+            if (!envValidation.isValid) {
+                throw new Error(`Environment variable validation failed in ${filePath}: ${envValidation.errors.join(", ")}`);
+            }
+            // Log warnings if any
+            if (envValidation.warnings.length > 0) {
+                console.warn(`Environment variable warnings in ${filePath}:\n- ${envValidation.warnings.join("\n- ")}`);
+            }
+        }
+        return {
+            hooks: config.hooks || undefined,
+            env: config.env || undefined,
+            defaultMode: config.defaultMode,
+            permissions: config.permissions || undefined,
+        };
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Invalid JSON syntax in ${filePath}: ${error.message}`);
+        }
+        // Re-throw validation errors and other errors as-is
+        throw error;
+    }
+}
+/**
+ * Load Wave configuration from multiple file paths in priority order
+ * Returns the first valid configuration found, or null if none exist
+ */
+export function loadWaveConfigFromFiles(filePaths) {
+    for (const filePath of filePaths) {
+        const config = loadWaveConfigFromFile(filePath);
+        if (config !== null) {
+            return config;
+        }
+    }
+    return null;
+}
+/**
+ * Load user-specific Wave configuration
+ * Checks .local.json first, then falls back to .json
+ */
+export function loadUserWaveConfig() {
+    return loadWaveConfigFromFiles(getUserConfigPaths());
+}
+/**
+ * Load project-specific Wave configuration
+ * Checks .local.json first, then falls back to .json
+ */
+export function loadProjectWaveConfig(workdir) {
+    return loadWaveConfigFromFiles(getProjectConfigPaths(workdir));
+}
+/**
+ * Load and merge Wave configuration from both user and project sources
+ * Project configuration takes precedence over user configuration
+ * Checks .local.json files first, then falls back to .json files
+ */
+export function loadMergedWaveConfig(workdir) {
+    const userConfig = loadUserWaveConfig();
+    const projectConfig = loadProjectWaveConfig(workdir);
+    // No configuration found
+    if (!userConfig && !projectConfig) {
+        return null;
+    }
+    // Only one configuration found
+    if (!userConfig)
+        return projectConfig;
+    if (!projectConfig)
+        return userConfig;
+    // Merge configurations (project overrides user)
+    const mergedHooks = {};
+    // Merge environment variables using the new mergeEnvironmentConfig function
+    const environmentContext = mergeEnvironmentConfig(userConfig.env, projectConfig.env, { includeConflictWarnings: true });
+    // Log environment variable conflicts if any
+    if (environmentContext.conflicts.length > 0) {
+        console.warn(`Environment variable conflicts detected (project values take precedence):\n${environmentContext.conflicts
+            .map((conflict) => `- ${conflict.key}: "${conflict.userValue}" → "${conflict.projectValue}"`)
+            .join("\n")}`);
+    }
+    // Merge hooks (combine arrays, project configs come after user configs)
+    const allEvents = new Set([
+        ...Object.keys(userConfig.hooks || {}),
+        ...Object.keys(projectConfig.hooks || {}),
+    ]);
+    for (const event of allEvents) {
+        if (!isValidHookEvent(event))
+            continue;
+        const userEventConfigs = userConfig.hooks?.[event] || [];
+        const projectEventConfigs = projectConfig.hooks?.[event] || [];
+        // Project configurations take precedence
+        mergedHooks[event] = [...userEventConfigs, ...projectEventConfigs];
+    }
+    // Merge permissions (combine allow arrays)
+    const mergedPermissions = {};
+    const userAllow = userConfig.permissions?.allow || [];
+    const projectAllow = projectConfig.permissions?.allow || [];
+    if (userAllow.length > 0 || projectAllow.length > 0) {
+        mergedPermissions.allow = [...new Set([...userAllow, ...projectAllow])];
+    }
+    return {
+        hooks: Object.keys(mergedHooks).length > 0 ? mergedHooks : undefined,
+        env: Object.keys(environmentContext.mergedVars).length > 0
+            ? environmentContext.mergedVars
+            : undefined,
+        // Project defaultMode takes precedence over user defaultMode
+        defaultMode: projectConfig.defaultMode ?? userConfig.defaultMode,
+        permissions: Object.keys(mergedPermissions).length > 0 ? mergedPermissions : undefined,
+    };
+}

package/dist/services/fileWatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fileWatcher.d.ts","sourceRoot":"","sources":["../../src/services/fileWatcher.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAGhD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,cAAc,CAAC;CAC5B;AAaD,qBAAa,kBAAmB,SAAQ,YAAY;IAClD,OAAO,CAAC,QAAQ,CAA4C;IAC5D,OAAO,CAAC,aAAa,CAAmC;IACxD,OAAO,CAAC,aAAa,CAAoB;IACzC,OAAO,CAAC,MAAM,CAAC,CAAS;gBAEZ,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC;IAahE;;;OAGG;IACG,SAAS,CACb,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GACxC,OAAO,CAAC,IAAI,CAAC;IA+BhB;;;OAGG;IACG,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB9C;;;OAGG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IA0BxD;;;OAGG;IACH,qBAAqB,IAAI,iBAAiB,EAAE;IAM5C;;;OAGG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,IAAI;IAStD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YAUhB,iBAAiB;IAkD/B,OAAO,CAAC,wBAAwB;IA4BhC,OAAO,CAAC,eAAe;CA8BxB"}
+{"version":3,"file":"fileWatcher.d.ts","sourceRoot":"","sources":["../../src/services/fileWatcher.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACtC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,iBAAiB;IAChC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,cAAc,CAAC;CAC5B;AAaD,qBAAa,kBAAmB,SAAQ,YAAY;IAClD,OAAO,CAAC,QAAQ,CAA4C;IAC5D,OAAO,CAAC,aAAa,CAAmC;IACxD,OAAO,CAAC,aAAa,CAAoB;IACzC,OAAO,CAAC,MAAM,CAAC,CAAS;gBAEZ,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC;IAahE;;;OAGG;IACG,SAAS,CACb,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GACxC,OAAO,CAAC,IAAI,CAAC;IA+BhB;;;OAGG;IACG,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB9C;;;OAGG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI;IA0BxD;;;OAGG;IACH,qBAAqB,IAAI,iBAAiB,EAAE;IAM5C;;;OAGG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,IAAI;IAStD;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YAUhB,iBAAiB;IAkD/B,OAAO,CAAC,wBAAwB;IA4BhC,OAAO,CAAC,eAAe;CA8BxB"}

package/dist/services/fileWatcher.js

@@ -6,7 +6,6 @@
  */
 import * as chokidar from "chokidar";
 import { EventEmitter } from "events";
-import { FILE_WATCHER_EVENTS } from "../constants/events.js";
 export class FileWatcherService extends EventEmitter {
     constructor(logger, config) {
         super();
@@ -92,7 +91,7 @@ export class FileWatcherService extends EventEmitter {
             lastError: entry.lastError,
             lastEvent: entry.lastEvent > 0
                 ? {
-                    type: FILE_WATCHER_EVENTS.CHANGE,
+                    type: "change",
                     path: entry.path,
                     timestamp: entry.lastEvent,
                 }
@@ -173,14 +172,14 @@ export class FileWatcherService extends EventEmitter {
     setupGlobalWatcherEvents() {
         if (!this.globalWatcher)
             return;
-        this.globalWatcher.on(FILE_WATCHER_EVENTS.CHANGE, (filePath, stats) => {
-            this.handleFileEvent(FILE_WATCHER_EVENTS.CHANGE, filePath, stats);
+        this.globalWatcher.on("change", (filePath, stats) => {
+            this.handleFileEvent("change", filePath, stats);
         });
         this.globalWatcher.on("add", (filePath, stats) => {
-            this.handleFileEvent(FILE_WATCHER_EVENTS.CREATE, filePath, stats);
+            this.handleFileEvent("create", filePath, stats);
         });
         this.globalWatcher.on("unlink", (filePath) => {
-            this.handleFileEvent(FILE_WATCHER_EVENTS.DELETE, filePath);
+            this.handleFileEvent("delete", filePath);
         });
         this.globalWatcher.on("error", (err) => {
             const error = err instanceof Error ? err : new Error(String(err));