@tenonhq/dovetail-core 0.0.85

package/dist/MultiScopeWatcher.js

@@ -0,0 +1,615 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multiScopeWatcher = void 0;
+exports.startMultiScopeWatching = startMultiScopeWatching;
+exports.stopMultiScopeWatching = stopMultiScopeWatching;
+const chokidar_1 = __importDefault(require("chokidar"));
+const logMessages_1 = require("./logMessages");
+const lodash_1 = require("lodash");
+const FileUtils_1 = require("./FileUtils");
+const appUtils_1 = require("./appUtils");
+const recentEdits_1 = require("./recentEdits");
+const Logger_1 = require("./Logger");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const ConfigManager = __importStar(require("./config"));
+const projectFiles_1 = require("./projectFiles");
+const DEBOUNCE_MS = 300;
+class MultiScopeWatcherManager {
+    scopeWatchers = new Map();
+    updateSetCheckInterval = null;
+    scopeLock = Promise.resolve();
+    cachedScope = null;
+    pendingScopes = new Map(); // scope -> first change timestamp
+    globalProcessQueue = null;
+    async startWatchingAllScopes(options) {
+        var opts = options || { monitorIntervalMs: 120000 };
+        try {
+            // Load configuration
+            await ConfigManager.loadConfigs();
+            const config = ConfigManager.getConfig();
+            if (!config.scopes) {
+                Logger_1.logger.error("No scopes defined in dove.config.js");
+                throw new Error("No scopes defined in configuration");
+            }
+            const scopes = Object.keys(config.scopes);
+            Logger_1.logger.info(`Starting multi-scope watch for ${scopes.length} scopes: ${scopes.join(", ")}`);
+            // Start watching each scope
+            for (const scopeName of scopes) {
+                const scopeConfig = config.scopes[scopeName];
+                let sourceDirectory;
+                if (typeof scopeConfig === "object" && scopeConfig.sourceDirectory) {
+                    sourceDirectory = path.resolve(ConfigManager.getRootDir(), scopeConfig.sourceDirectory);
+                }
+                else {
+                    // Default to src/{scope} if no sourceDirectory specified
+                    sourceDirectory = path.resolve(ConfigManager.getRootDir(), "src", scopeName);
+                }
+                this.startWatchingScope(scopeName, sourceDirectory);
+            }
+            // Start periodic update set checking (unless disabled)
+            if (opts.monitorIntervalMs > 0) {
+                this.startUpdateSetMonitoring(opts.monitorIntervalMs);
+            }
+            else {
+                Logger_1.logger.info("Update set monitoring disabled (--noMonitoring)");
+            }
+            Logger_1.logger.success("✅ Multi-scope watch started successfully!");
+            Logger_1.logger.info("Watching for file changes across all scopes...");
+            Logger_1.logger.info("Press Ctrl+C to stop watching\n");
+        }
+        catch (error) {
+            Logger_1.logger.error("Failed to start multi-scope watch: " + error);
+            throw error;
+        }
+    }
+    startWatchingScope(scopeName, sourceDirectory) {
+        Logger_1.logger.info(`Setting up watcher for scope ${scopeName} in ${sourceDirectory}`);
+        const watcher = chokidar_1.default.watch(sourceDirectory, {
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 300,
+                pollInterval: 100
+            }
+        });
+        const scopeWatcher = {
+            scope: scopeName,
+            watcher: watcher,
+            pushQueue: [],
+            sourceDirectory: sourceDirectory
+        };
+        // Initialize global debounce once (shared across all scopes)
+        if (!this.globalProcessQueue) {
+            this.globalProcessQueue = (0, lodash_1.debounce)(async () => {
+                await this.processAllPendingScopes();
+            }, DEBOUNCE_MS);
+        }
+        watcher.on("change", (filePath) => {
+            Logger_1.logger.info(`[${scopeName}] File changed: ${path.relative(sourceDirectory, filePath)}`);
+            scopeWatcher.pushQueue.push(filePath);
+            if (!this.pendingScopes.has(scopeName)) {
+                this.pendingScopes.set(scopeName, Date.now());
+            }
+            this.globalProcessQueue();
+        });
+        watcher.on("add", (filePath) => {
+            Logger_1.logger.info(`[${scopeName}] File added: ${path.relative(sourceDirectory, filePath)}`);
+            scopeWatcher.pushQueue.push(filePath);
+            if (!this.pendingScopes.has(scopeName)) {
+                this.pendingScopes.set(scopeName, Date.now());
+            }
+            this.globalProcessQueue();
+        });
+        watcher.on("error", (error) => {
+            Logger_1.logger.error(`[${scopeName}] Watcher error: ${error.message}`);
+        });
+        this.scopeWatchers.set(scopeName, scopeWatcher);
+    }
+    async withScopeLock(fn) {
+        var resolve;
+        var next = new Promise(function (r) { resolve = r; });
+        var prev = this.scopeLock;
+        this.scopeLock = next;
+        await prev;
+        try {
+            return await fn();
+        }
+        finally {
+            resolve();
+        }
+    }
+    getUpdateSetConfig() {
+        var configPath = (0, projectFiles_1.getUpdateSetsConfigPath)();
+        try {
+            if (fs.existsSync(configPath)) {
+                return JSON.parse(fs.readFileSync(configPath, "utf8"));
+            }
+        }
+        catch (e) {
+            Logger_1.logger.warn(`[MultiScope] Failed to parse update set config at ${configPath}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        return {};
+    }
+    readActiveTask() {
+        var taskPath = (0, projectFiles_1.getActiveTaskPath)();
+        try {
+            if (fs.existsSync(taskPath)) {
+                var parsed = JSON.parse(fs.readFileSync(taskPath, "utf8"));
+                if (!parsed.taskId || typeof parsed.taskId !== "string" || parsed.taskId.trim() === "") {
+                    Logger_1.logger.error("Active task file is missing a valid taskId. Ignoring active task.");
+                    return null;
+                }
+                if (!parsed.updateSetName || typeof parsed.updateSetName !== "string" || parsed.updateSetName.trim() === "") {
+                    Logger_1.logger.error("Active task file is missing a valid updateSetName. Ignoring active task.");
+                    return null;
+                }
+                var stat = fs.statSync(taskPath);
+                var ageMs = Date.now() - stat.mtimeMs;
+                var ageDays = Math.floor(ageMs / (1000 * 60 * 60 * 24));
+                if (ageDays >= 7) {
+                    var taskName = parsed.taskName || parsed.taskId;
+                    Logger_1.logger.warn("Active task " + taskName + " was selected " + ageDays + " days ago. Run dove task clear if you have moved on.");
+                }
+                return parsed;
+            }
+        }
+        catch (e) {
+            Logger_1.logger.warn(`Failed to parse active task file: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        return null;
+    }
+    saveUpdateSetConfig(config) {
+        var configPath = (0, projectFiles_1.getUpdateSetsConfigPath)();
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+    async ensureUpdateSetForScope(scopeName) {
+        var config = this.getUpdateSetConfig();
+        if (config[scopeName]) {
+            return; // Already has an update set mapped
+        }
+        var activeTask = this.readActiveTask();
+        if (!activeTask) {
+            // No active task — try to resolve the current update set from the ServiceNow
+            // session so pushWithUpdateSet can be used instead of the fallback updateRecord.
+            try {
+                var { defaultClient } = await Promise.resolve().then(() => __importStar(require("./snClient")));
+                var sessionClient = defaultClient();
+                var curResp = await sessionClient.getCurrentUpdateSet(scopeName);
+                var curData = curResp.data;
+                if (curData && curData.result) {
+                    curData = curData.result;
+                }
+                var curSysId = curData && curData.sysId ? curData.sysId : null;
+                var curName = curData && curData.name ? curData.name : null;
+                if (curSysId && curName) {
+                    var isDefault = curName === "Default" || curName.toLowerCase().indexOf("default") !== -1;
+                    if (isDefault) {
+                        Logger_1.logger.warn(`[${scopeName}] No update set configured for scope ${scopeName}. ` +
+                            `Changes will go to Default. ` +
+                            `Use dove createUpdateSet or activate a task in the dashboard.`);
+                    }
+                    else {
+                        // Use the session's current non-Default update set
+                        config = this.getUpdateSetConfig();
+                        config[scopeName] = { sys_id: curSysId, name: curName };
+                        this.saveUpdateSetConfig(config);
+                        Logger_1.logger.info(`[${scopeName}] Using session update set: ${curName}`);
+                    }
+                }
+                else {
+                    Logger_1.logger.warn(`[${scopeName}] No update set configured for scope ${scopeName}. ` +
+                        `Changes will go to Default. ` +
+                        `Use dove createUpdateSet or activate a task in the dashboard.`);
+                }
+            }
+            catch (queryErr) {
+                Logger_1.logger.warn(`[${scopeName}] No update set configured for scope ${scopeName}. ` +
+                    `Changes will go to Default (could not query current update set). ` +
+                    `Use dove createUpdateSet or activate a task in the dashboard.`);
+            }
+            return;
+        }
+        var taskId = activeTask.taskId;
+        var updateSetName = activeTask.updateSetName;
+        var description = activeTask.description || "";
+        if (!taskId || taskId.trim() === "") {
+            Logger_1.logger.error(`[${scopeName}] Active task has an empty taskId. Skipping update set lookup.`);
+            return;
+        }
+        Logger_1.logger.info(`[${scopeName}] No update set found — auto-creating for task CU-${taskId}...`);
+        try {
+            var { defaultClient, unwrapSNResponse } = await Promise.resolve().then(() => __importStar(require("./snClient")));
+            var client = defaultClient();
+            // Switch to the target scope and resolve its sys_id for update set creation
+            await client.changeScope(scopeName);
+            var scopeIdResult = await unwrapSNResponse(client.getScopeId(scopeName));
+            var scopeSysId = scopeIdResult && scopeIdResult.length > 0 ? scopeIdResult[0].sys_id : undefined;
+            if (!scopeSysId) {
+                Logger_1.logger.error(`[${scopeName}] Scope "${scopeName}" not found on the instance. Cannot create update set for an invalid scope.`);
+                return;
+            }
+            // Search for an existing update set matching this task in this scope
+            var query = "application.scope=" + scopeName +
+                "^nameLIKECU-" + taskId +
+                "^state=in progress" +
+                "^ORDERBYDESCsys_created_on";
+            var searchResp = await client.client.get("api/now/table/sys_update_set", {
+                params: {
+                    sysparm_query: query,
+                    sysparm_fields: "sys_id,name,state,application,sys_created_on",
+                    sysparm_limit: "10",
+                },
+            });
+            var existing = (searchResp.data && searchResp.data.result) || [];
+            var updateSet = null;
+            if (existing.length > 0) {
+                updateSet = { sys_id: existing[0].sys_id, name: existing[0].name };
+                Logger_1.logger.info(`[${scopeName}] Found existing update set: ${updateSet.name}`);
+            }
+            else {
+                // Create a new one with explicit scope sys_id
+                var createResp = await unwrapSNResponse(client.createUpdateSet(updateSetName, scopeSysId, description));
+                updateSet = { sys_id: createResp.sys_id, name: updateSetName };
+                Logger_1.logger.info(`[${scopeName}] Auto-created update set: ${updateSet.name}`);
+            }
+            // Switch the active update set on the instance and verify
+            try {
+                await client.changeUpdateSet({ sysId: updateSet.sys_id });
+                // Verify the switch was successful
+                var verifyResp = await client.getCurrentUpdateSet(scopeName);
+                var verifyResult = verifyResp.data;
+                if (verifyResult && verifyResult.result) {
+                    verifyResult = verifyResult.result;
+                }
+                var currentSysId = verifyResult && verifyResult.sysId ? verifyResult.sysId : null;
+                if (currentSysId !== updateSet.sys_id) {
+                    // Retry once
+                    Logger_1.logger.warn(`[${scopeName}] Update set verification failed, retrying switch...`);
+                    await client.changeUpdateSet({ sysId: updateSet.sys_id });
+                    var retryResp = await client.getCurrentUpdateSet(scopeName);
+                    var retryResult = retryResp.data;
+                    if (retryResult && retryResult.result) {
+                        retryResult = retryResult.result;
+                    }
+                    var retrySysId = retryResult && retryResult.sysId ? retryResult.sysId : null;
+                    if (retrySysId !== updateSet.sys_id) {
+                        var actualName = retryResult && retryResult.name ? retryResult.name : "unknown";
+                        Logger_1.logger.error(`[${scopeName}] Update set ${updateSet.name} was created but could not be activated. Current update set is ${actualName}.`);
+                        throw new Error(`Update set ${updateSet.name} could not be activated for scope ${scopeName}`);
+                    }
+                }
+                Logger_1.logger.debug(`[${scopeName}] Update set switch verified: ${updateSet.name}`);
+            }
+            catch (changeErr) {
+                Logger_1.logger.warn(`[${scopeName}] Could not auto-switch update set on instance`);
+            }
+            // Persist the mapping (serialized under scopeLock — safe from concurrent writes)
+            config = this.getUpdateSetConfig(); // Re-read in case another scope wrote
+            config[scopeName] = { sys_id: updateSet.sys_id, name: updateSet.name };
+            this.saveUpdateSetConfig(config);
+            // Verify the write persisted correctly
+            var verifiedConfig = this.getUpdateSetConfig();
+            if (!verifiedConfig[scopeName] || verifiedConfig[scopeName].sys_id !== updateSet.sys_id) {
+                Logger_1.logger.error(`[${scopeName}] Update set config write verification failed. Expected mapping for ${scopeName} with sys_id ${updateSet.sys_id} but got: ${JSON.stringify(verifiedConfig[scopeName])}`);
+                throw new Error(`Update set config write verification failed for scope ${scopeName}`);
+            }
+            Logger_1.logger.debug(`[${scopeName}] Update set config verified: ${updateSet.name} (${updateSet.sys_id})`);
+            // Also update the active task file
+            if (activeTask) {
+                if (!activeTask.scopes) {
+                    activeTask.scopes = {};
+                }
+                activeTask.scopes[scopeName] = { sys_id: updateSet.sys_id, name: updateSet.name };
+                fs.writeFileSync((0, projectFiles_1.getActiveTaskPath)(), JSON.stringify(activeTask, null, 2));
+            }
+        }
+        catch (error) {
+            Logger_1.logger.error(`[${scopeName}] Failed to auto-create update set: ${error}`);
+            Logger_1.logger.warn(`[${scopeName}] Pushing without update set routing.`);
+        }
+    }
+    async processAllPendingScopes() {
+        // Sort scopes by first file change timestamp (FIFO)
+        var sorted = Array.from(this.pendingScopes.entries()).sort(function (a, b) {
+            return a[1] - b[1];
+        });
+        this.pendingScopes.clear();
+        for (var i = 0; i < sorted.length; i++) {
+            var scopeName = sorted[i][0];
+            var scopeWatcher = this.scopeWatchers.get(scopeName);
+            if (scopeWatcher && scopeWatcher.pushQueue.length > 0) {
+                await this.processScopeQueue(scopeWatcher);
+            }
+        }
+    }
+    async processScopeQueue(scopeWatcher) {
+        if (scopeWatcher.pushQueue.length === 0)
+            return;
+        const toProcess = Array.from(new Set([...scopeWatcher.pushQueue]));
+        scopeWatcher.pushQueue = [];
+        Logger_1.logger.info(`[${scopeWatcher.scope}] Processing ${toProcess.length} file(s)...`);
+        try {
+            await this.withScopeLock(async () => {
+                // First, switch to the correct scope
+                await this.switchToScope(scopeWatcher.scope);
+                // Ensure an update set exists for this scope
+                await this.ensureUpdateSetForScope(scopeWatcher.scope);
+                // Load the manifest for this specific scope
+                await this.loadScopeManifest(scopeWatcher.scope, scopeWatcher.sourceDirectory);
+                // Process the files — track skip reasons for summary
+                const fileContexts = [];
+                const skippedFiles = [];
+                toProcess.forEach(function (filePath) {
+                    var result = (0, FileUtils_1.getFileContextWithSkipReason)(filePath);
+                    if (result.context) {
+                        // Scope validation: ensure the record's scope matches the watcher's scope
+                        if (result.context.scope && result.context.scope !== scopeWatcher.scope) {
+                            Logger_1.logger.error(`[${scopeWatcher.scope}] Scope mismatch: ${filePath} belongs to scope "${result.context.scope}" but was queued by watcher for "${scopeWatcher.scope}". Skipping to prevent cross-scope contamination.`);
+                            skippedFiles.push({ filePath: filePath, reason: `scope mismatch (record: ${result.context.scope}, watcher: ${scopeWatcher.scope})` });
+                        }
+                        else {
+                            fileContexts.push(result.context);
+                        }
+                    }
+                    else {
+                        var reason = result.skipReason || "unknown";
+                        Logger_1.logger.warn(`[${scopeWatcher.scope}] Skipped: ${filePath} (${reason})`);
+                        skippedFiles.push({ filePath: filePath, reason: reason });
+                    }
+                });
+                if (fileContexts.length === 0) {
+                    Logger_1.logger.warn(`[${scopeWatcher.scope}] No valid file contexts found. ${skippedFiles.length} file(s) skipped.`);
+                    return;
+                }
+                const buildables = (0, appUtils_1.groupAppFiles)(fileContexts);
+                const updateResults = await (0, appUtils_1.pushFiles)(buildables);
+                updateResults.forEach((res, index) => {
+                    if (index < fileContexts.length) {
+                        (0, logMessages_1.logFilePush)(fileContexts[index], res);
+                        if (res.success) {
+                            (0, recentEdits_1.writeRecentEdit)(fileContexts[index]);
+                        }
+                    }
+                });
+                // Push summary
+                var pushedCount = updateResults.filter(function (r) { return r.success; }).length;
+                var totalCount = toProcess.length;
+                var summaryParts = [`Pushed ${pushedCount}/${totalCount} files to ${scopeWatcher.scope}.`];
+                if (skippedFiles.length > 0) {
+                    var skippedList = skippedFiles.map(function (s) { return `${s.filePath} (${s.reason})`; }).join(", ");
+                    summaryParts.push(`${skippedFiles.length} files skipped: [${skippedList}]`);
+                }
+                Logger_1.logger.info(`[${scopeWatcher.scope}] ${summaryParts.join(" ")}`);
+            });
+        }
+        catch (error) {
+            Logger_1.logger.error(`[${scopeWatcher.scope}] Error processing queue: ${error}`);
+        }
+    }
+    async loadScopeManifest(scopeName, sourceDirectory) {
+        try {
+            // The sourceDirectory is like /path/to/ServiceNow/src/x_cadso_core
+            // We need to go up two levels to get to the ServiceNow directory where manifests are stored
+            const projectRoot = path.dirname(path.dirname(sourceDirectory)); // Go up from src/scope to project root
+            const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+            // First try to load scope-specific manifest file (prefer dove.*, fall back to sinc.*).
+            const doveScopeManifestPath = path.join(projectRoot, `dove.manifest.${scopeName}.json`);
+            const sincScopeManifestPath = path.join(projectRoot, `sinc.manifest.${scopeName}.json`);
+            const scopeManifestPath = fs.existsSync(doveScopeManifestPath)
+                ? doveScopeManifestPath
+                : sincScopeManifestPath;
+            if (fs.existsSync(scopeManifestPath)) {
+                const manifestContent = await fs.promises.readFile(scopeManifestPath, "utf-8");
+                const scopeManifest = JSON.parse(manifestContent);
+                // Ensure scope field is set
+                if (!scopeManifest.scope) {
+                    scopeManifest.scope = scopeName;
+                }
+                ConfigManager.updateManifest(scopeManifest);
+                Logger_1.logger.debug(`Loaded scope-specific manifest for: ${scopeName}`);
+                return;
+            }
+            // Fall back to checking single manifest file (prefer dove.manifest.json, then legacy sinc.manifest.json)
+            const doveManifestPath = path.join(projectRoot, "dove.manifest.json");
+            const sincManifestPath = path.join(projectRoot, "sinc.manifest.json");
+            const manifestPath = fs.existsSync(doveManifestPath) ? doveManifestPath : sincManifestPath;
+            if (fs.existsSync(manifestPath)) {
+                const manifestContent = await fs.promises.readFile(manifestPath, "utf-8");
+                const fullManifest = JSON.parse(manifestContent);
+                // Check if this is a multi-scope manifest (has scopes as top-level keys)
+                if (fullManifest[scopeName]) {
+                    // Multi-scope manifest - extract the specific scope's data
+                    const scopeManifest = fullManifest[scopeName];
+                    // Add the scope field for compatibility
+                    scopeManifest.scope = scopeName;
+                    ConfigManager.updateManifest(scopeManifest);
+                    Logger_1.logger.debug(`Loaded manifest for scope: ${scopeName} from legacy multi-scope manifest`);
+                }
+                else if (fullManifest.scope === scopeName) {
+                    // Single-scope manifest for the correct scope
+                    ConfigManager.updateManifest(fullManifest);
+                    Logger_1.logger.debug(`Loaded single-scope manifest for scope: ${scopeName}`);
+                }
+                else if (fullManifest.tables) {
+                    // Old-style single-scope manifest without scope field - assume it's for this scope
+                    fullManifest.scope = scopeName;
+                    ConfigManager.updateManifest(fullManifest);
+                    Logger_1.logger.debug(`Loaded manifest for scope: ${scopeName} (legacy format)`);
+                }
+                else {
+                    Logger_1.logger.warn(`[${scopeName}] Scope not found in manifest`);
+                }
+            }
+            else {
+                Logger_1.logger.warn(`[${scopeName}] No manifest found at ${scopeManifestPath} or ${manifestPath}`);
+            }
+        }
+        catch (error) {
+            Logger_1.logger.error(`Failed to load manifest for scope ${scopeName}: ${error}`);
+        }
+    }
+    async switchToScope(scopeName) {
+        // Skip if already on the correct scope
+        if (this.cachedScope === scopeName) {
+            Logger_1.logger.debug(`Already on scope ${scopeName}, skipping switch`);
+            return;
+        }
+        try {
+            var { defaultClient } = await Promise.resolve().then(() => __importStar(require("./snClient")));
+            var client = defaultClient();
+            // Use the Claude REST API changeScope endpoint to switch the session scope.
+            // This uses gs.setCurrentApplicationId() server-side, which correctly changes
+            // the REST API session scope. The previous approach used user preference updates
+            // (apps.current_app) which only writes a DB record and does NOT affect the
+            // active REST session — causing updateRecord() to operate in the wrong scope.
+            await client.changeScope(scopeName);
+            this.cachedScope = scopeName;
+            Logger_1.logger.debug(`Switched to scope: ${scopeName}`);
+        }
+        catch (error) {
+            // Invalidate cache on failure
+            this.cachedScope = null;
+            Logger_1.logger.error(`Failed to switch to scope ${scopeName}: ${error}`);
+            throw error;
+        }
+    }
+    async startUpdateSetMonitoring(intervalMs) {
+        // Check update sets immediately on start
+        await this.checkAllUpdateSets();
+        Logger_1.logger.info("Update set monitoring interval: " + Math.round(intervalMs / 1000) + "s");
+        this.updateSetCheckInterval = setInterval(async () => {
+            await this.checkAllUpdateSets();
+        }, intervalMs);
+    }
+    async checkAllUpdateSets() {
+        // Budget: monitoring should not consume more than 5% of the 20 RPS rate limit
+        // per cycle. That gives us ~1 request/second budget. Each scope check uses
+        // ~6 API calls (switchToScope ~3, getUserSysId ~1, pref ~1, details ~1).
+        // To stay within budget we use the local update set config file instead of
+        // querying ServiceNow for each scope — 0 API calls when config is present.
+        try {
+            const config = ConfigManager.getConfig();
+            if (!config.scopes)
+                return;
+            const scopes = Object.keys(config.scopes);
+            var updateSetConfig = this.getUpdateSetConfig();
+            Logger_1.logger.info("\n" + "=".repeat(60));
+            Logger_1.logger.info("Update Set Status Check");
+            Logger_1.logger.info("=".repeat(60));
+            for (var i = 0; i < scopes.length; i++) {
+                var scopeName = scopes[i];
+                var mapping = updateSetConfig[scopeName];
+                if (mapping && mapping.name) {
+                    var isDefault = mapping.name === "Default" ||
+                        mapping.name.toLowerCase().indexOf("default") !== -1;
+                    if (isDefault) {
+                        Logger_1.logger.warn(`⚠️  [${scopeName}] Currently in DEFAULT update set!`);
+                    }
+                    else {
+                        Logger_1.logger.info(`✅ [${scopeName}] Update Set: ${mapping.name}`);
+                    }
+                }
+                else {
+                    Logger_1.logger.warn(`⚠️  [${scopeName}] No update set configured`);
+                }
+            }
+            Logger_1.logger.info("=".repeat(60) + "\n");
+        }
+        catch (error) {
+            Logger_1.logger.error(`Error during update set monitoring: ${error}`);
+        }
+    }
+    async getUpdateSetDetails(updateSetId) {
+        try {
+            const { defaultClient } = await Promise.resolve().then(() => __importStar(require("./snClient")));
+            const client = defaultClient();
+            // Create axios client directly to get update set details
+            const axios = (await Promise.resolve().then(() => __importStar(require("axios")))).default;
+            const { SN_USER = "", SN_PASSWORD = "", SN_INSTANCE = "" } = process.env;
+            const axiosClient = axios.create({
+                auth: {
+                    username: SN_USER,
+                    password: SN_PASSWORD
+                },
+                baseURL: SN_INSTANCE
+            });
+            const response = await axiosClient.get(`/api/now/table/sys_update_set/${updateSetId}`, {
+                params: {
+                    sysparm_fields: "name,state,sys_id"
+                }
+            });
+            if (response.data && response.data.result) {
+                return response.data.result;
+            }
+            return null;
+        }
+        catch (error) {
+            Logger_1.logger.warn(`Could not get update set details: ${error}`);
+            return null;
+        }
+    }
+    stopWatching() {
+        // Stop all scope watchers
+        for (const [scopeName, scopeWatcher] of this.scopeWatchers) {
+            Logger_1.logger.info(`Stopping watcher for scope: ${scopeName}`);
+            scopeWatcher.watcher.close();
+        }
+        this.scopeWatchers.clear();
+        // Cancel global debounce
+        if (this.globalProcessQueue) {
+            this.globalProcessQueue.cancel();
+            this.globalProcessQueue = null;
+        }
+        this.pendingScopes.clear();
+        // Stop update set monitoring
+        if (this.updateSetCheckInterval) {
+            clearInterval(this.updateSetCheckInterval);
+            this.updateSetCheckInterval = null;
+        }
+        Logger_1.logger.info("All watchers stopped");
+    }
+}
+exports.multiScopeWatcher = new MultiScopeWatcherManager();
+function startMultiScopeWatching(options) {
+    return exports.multiScopeWatcher.startWatchingAllScopes(options);
+}
+function stopMultiScopeWatching() {
+    exports.multiScopeWatcher.stopWatching();
+}