tabby-mcp-server 1.3.0 → 1.4.2

package/dist/index.js

@@ -6726,6 +6726,7 @@ exports["default"] = def;
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 const code_1 = __webpack_require__(5765);
+const util_1 = __webpack_require__(4227);
 const codegen_1 = __webpack_require__(1410);
 const error = {
     message: ({ schemaCode }) => (0, codegen_1.str) `must match pattern "${schemaCode}"`,
@@ -6738,11 +6739,19 @@ const def = {
     $data: true,
     error,
     code(cxt) {
-        const { data, $data, schema, schemaCode, it } = cxt;
-        // TODO regexp should be wrapped in try/catchs
+        const { gen, data, $data, schema, schemaCode, it } = cxt;
         const u = it.opts.unicodeRegExp ? "u" : "";
-        const regExp = $data ? (0, codegen_1._) `(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
-        cxt.fail$data((0, codegen_1._) `!${regExp}.test(${data})`);
+        if ($data) {
+            const { regExp } = it.opts.code;
+            const regExpCode = regExp.code === "new RegExp" ? (0, codegen_1._) `new RegExp` : (0, util_1.useFunc)(gen, regExp);
+            const valid = gen.let("valid");
+            gen.try(() => gen.assign(valid, (0, codegen_1._) `${regExpCode}(${schemaCode}, ${u}).test(${data})`), () => gen.assign(valid, false));
+            cxt.fail$data((0, codegen_1._) `!${valid}`);
+        }
+        else {
+            const regExp = (0, code_1.usePattern)(cxt, schema);
+            cxt.fail$data((0, codegen_1._) `!${regExp}.test(${data})`);
+        }
     },
 };
 exports["default"] = def;
@@ -25022,7 +25031,7 @@ var parseValues = function parseQueryStringValues(str, options) {
     var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, '') : str;
     cleanStr = cleanStr.replace(/%5B/gi, '[').replace(/%5D/gi, ']');
 
-    var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;
+    var limit = options.parameterLimit === Infinity ? void undefined : options.parameterLimit;
     var parts = cleanStr.split(
         options.delimiter,
         options.throwOnLimitExceeded ? limit + 1 : limit
@@ -25089,6 +25098,13 @@ var parseValues = function parseQueryStringValues(str, options) {
             val = isArray(val) ? [val] : val;
         }
 
+        if (options.comma && isArray(val) && val.length > options.arrayLimit) {
+            if (options.throwOnLimitExceeded) {
+                throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+            }
+            val = utils.combine([], val, options.arrayLimit, options.plainObjects);
+        }
+
         if (key !== null) {
             var existing = has.call(obj, key);
             if (existing && options.duplicates === 'combine') {
@@ -25139,17 +25155,21 @@ var parseObject = function (chain, val, options, valuesParsed) {
             var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
             var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, '.') : cleanRoot;
             var index = parseInt(decodedRoot, 10);
-            if (!options.parseArrays && decodedRoot === '') {
-                obj = { 0: leaf };
-            } else if (
-                !isNaN(index)
+            var isValidArrayIndex = !isNaN(index)
                 && root !== decodedRoot
                 && String(index) === decodedRoot
                 && index >= 0
-                && (options.parseArrays && index <= options.arrayLimit)
-            ) {
+                && options.parseArrays;
+            if (!options.parseArrays && decodedRoot === '') {
+                obj = { 0: leaf };
+            } else if (isValidArrayIndex && index < options.arrayLimit) {
                 obj = [];
                 obj[index] = leaf;
+            } else if (isValidArrayIndex && options.throwOnLimitExceeded) {
+                throw new RangeError('Array limit exceeded. Only ' + options.arrayLimit + ' element' + (options.arrayLimit === 1 ? '' : 's') + ' allowed in an array.');
+            } else if (isValidArrayIndex) {
+                obj[index] = leaf;
+                utils.markOverflow(obj, index);
             } else if (decodedRoot !== '__proto__') {
                 obj[decodedRoot] = leaf;
             }
@@ -25189,7 +25209,7 @@ var splitKeyIntoSegments = function splitKeyIntoSegments(givenKey, options) {
             }
         }
 
-        keys.push(parent);
+        keys[keys.length] = parent;
     }
 
     var i = 0;
@@ -25203,7 +25223,7 @@ var splitKeyIntoSegments = function splitKeyIntoSegments(givenKey, options) {
             }
         }
 
-        keys.push(segment[1]);
+        keys[keys.length] = segment[1];
     }
 
     if (segment) {
@@ -25211,7 +25231,7 @@ var splitKeyIntoSegments = function splitKeyIntoSegments(givenKey, options) {
             throw new RangeError('Input depth exceeded depth option of ' + options.depth + ' and strictDepth is true');
         }
 
-        keys.push('[' + key.slice(segment.index) + ']');
+        keys[keys.length] = '[' + key.slice(segment.index) + ']';
     }
 
     return keys;
@@ -25721,7 +25741,7 @@ var setMaxIndex = function setMaxIndex(obj, maxIndex) {
 var hexTable = (function () {
     var array = [];
     for (var i = 0; i < 256; ++i) {
-        array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
+        array[array.length] = '%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase();
     }
 
     return array;
@@ -25737,7 +25757,7 @@ var compactQueue = function compactQueue(queue) {
 
             for (var j = 0; j < obj.length; ++j) {
                 if (typeof obj[j] !== 'undefined') {
-                    compacted.push(obj[j]);
+                    compacted[compacted.length] = obj[j];
                 }
             }
 
@@ -25765,7 +25785,11 @@ var merge = function merge(target, source, options) {
 
     if (typeof source !== 'object' && typeof source !== 'function') {
         if (isArray(target)) {
-            target.push(source);
+            var nextIndex = target.length;
+            if (options && typeof options.arrayLimit === 'number' && nextIndex > options.arrayLimit) {
+                return markOverflow(arrayToObject(target.concat(source), options), nextIndex);
+            }
+            target[nextIndex] = source;
         } else if (target && typeof target === 'object') {
             if (isOverflow(target)) {
                 // Add at next numeric index for overflow objects
@@ -25798,7 +25822,11 @@ var merge = function merge(target, source, options) {
             }
             return markOverflow(result, getMaxIndex(source) + 1);
         }
-        return [target].concat(source);
+        var combined = [target].concat(source);
+        if (options && typeof options.arrayLimit === 'number' && combined.length > options.arrayLimit) {
+            return markOverflow(arrayToObject(combined, options), combined.length - 1);
+        }
+        return combined;
     }
 
     var mergeTarget = target;
@@ -25813,7 +25841,7 @@ var merge = function merge(target, source, options) {
                 if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
                     target[i] = merge(targetItem, item, options);
                 } else {
-                    target.push(item);
+                    target[target.length] = item;
                 }
             } else {
                 target[i] = item;
@@ -25830,6 +25858,17 @@ var merge = function merge(target, source, options) {
         } else {
             acc[key] = value;
         }
+
+        if (isOverflow(source) && !isOverflow(acc)) {
+            markOverflow(acc, getMaxIndex(source));
+        }
+        if (isOverflow(acc)) {
+            var keyNum = parseInt(key, 10);
+            if (String(keyNum) === key && keyNum >= 0 && keyNum > getMaxIndex(acc)) {
+                setMaxIndex(acc, keyNum);
+            }
+        }
+
         return acc;
     }, mergeTarget);
 };
@@ -25946,8 +25985,8 @@ var compact = function compact(value) {
             var key = keys[j];
             var val = obj[key];
             if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
-                queue.push({ obj: obj, prop: key });
-                refs.push(val);
+                queue[queue.length] = { obj: obj, prop: key };
+                refs[refs.length] = val;
             }
         }
     }
@@ -25989,7 +26028,7 @@ var maybeMap = function maybeMap(val, fn) {
     if (isArray(val)) {
         var mapped = [];
         for (var i = 0; i < val.length; i += 1) {
-            mapped.push(fn(val[i]));
+            mapped[mapped.length] = fn(val[i]);
         }
         return mapped;
     }
@@ -26006,6 +26045,7 @@ module.exports = {
     isBuffer: isBuffer,
     isOverflow: isOverflow,
     isRegExp: isRegExp,
+    markOverflow: markOverflow,
     maybeMap: maybeMap,
     merge: merge
 };
@@ -32101,8 +32141,7 @@ let McpSettingsTabComponent = class McpSettingsTabComponent {
     }
     exportLogsToFile() {
         const logs = this.logger.exportLogs();
-        const json = JSON.stringify(logs, null, 2);
-        const blob = new Blob([json], { type: 'application/json' });
+        const blob = new Blob([logs], { type: 'application/json' });
         const url = URL.createObjectURL(blob);
         const a = document.createElement('a');
         a.href = url;
@@ -32175,7 +32214,7 @@ let McpSettingsTabComponent = class McpSettingsTabComponent {
         return JSON.stringify({
             mcpServers: {
                 'Tabby MCP': {
-                    type: 'sse',
+                    type: 'streamable_http',
                     url: `http://localhost:${port}/mcp`
                 }
             }
@@ -33674,11 +33713,16 @@ let McpService = class McpService {
     constructor(config, logger) {
         this.config = config;
         this.logger = logger;
+        // Per-session McpServer instances - each client gets its own server to avoid SDK Bug #1459
+        // This prevents one client's disconnect from affecting other clients' pending requests
+        this.sessionServers = {};
         this.legacyTransports = {};
         this.streamableTransports = {};
         this.sockets = new Set();
         this.isRunning = false;
         this.toolCategories = [];
+        // Store tool definitions for registering with each new server
+        this.registeredTools = [];
         // ============================================================
         // CONNECTION MONITORING & MANAGEMENT
         // ============================================================
@@ -33686,20 +33730,41 @@ let McpService = class McpService {
         this.initializeServer();
     }
     /**
-     * Initialize the MCP server
+     * Initialize the MCP service (no longer creates a single server)
      */
     initializeServer() {
-        // Initialize MCP Server
-        this.server = new mcp_js_1.McpServer({
+        // Configure Express - servers are created per-session now
+        this.configureExpress();
+        this.logger.info('MCP Service initialized (Streamable HTTP + Legacy SSE) - per-session servers');
+    }
+    /**
+     * Create a new McpServer instance for a specific session
+     * Each client gets its own server to avoid SDK Bug #1459
+     */
+    createServerForSession(sessionId) {
+        const server = new mcp_js_1.McpServer({
             name: 'Tabby MCP',
             version: version_1.PLUGIN_VERSION
         });
-        // Configure Express
-        this.configureExpress();
-        this.logger.info('MCP Server initialized (Streamable HTTP + Legacy SSE)');
+        // Register all tools with this server instance
+        for (const toolDef of this.registeredTools) {
+            server.tool(toolDef.name, toolDef.description, toolDef.schema, toolDef.handler);
+        }
+        this.sessionServers[sessionId] = server;
+        this.logger.debug(`[Session ${sessionId}] Created new McpServer with ${this.registeredTools.length} tools`);
+        return server;
     }
     /**
-     * Register a tool category with the MCP server
+     * Clean up server for a specific session
+     */
+    cleanupServerForSession(sessionId) {
+        if (this.sessionServers[sessionId]) {
+            delete this.sessionServers[sessionId];
+            this.logger.debug(`[Session ${sessionId}] Cleaned up McpServer`);
+        }
+    }
+    /**
+     * Register a tool category - stores definitions for per-session server creation
      */
     registerToolCategory(category) {
         this.toolCategories.push(category);
@@ -33710,20 +33775,32 @@ let McpService = class McpService {
                 ? tool.schema.shape
                 : tool.schema;
             this.logger.debug(`Registering tool: ${tool.name} with schema keys: ${Object.keys(rawShape || {}).join(', ')}`);
-            this.server.tool(tool.name, tool.description, rawShape, tool.handler);
-            this.logger.info(`Registered tool: ${tool.name}`);
+            // Store tool definition for later registration with per-session servers
+            this.registeredTools.push({
+                name: tool.name,
+                description: tool.description,
+                schema: rawShape,
+                handler: tool.handler
+            });
+            this.logger.info(`Registered tool definition: ${tool.name}`);
         });
     }
     /**
-     * Register a single tool
+     * Register a single tool - stores definition for per-session server creation
      */
     registerTool(tool) {
         // Extract the raw shape from z.object() for MCP SDK compatibility
         const rawShape = tool.schema && typeof tool.schema === 'object' && 'shape' in tool.schema
             ? tool.schema.shape
             : tool.schema;
-        this.server.tool(tool.name, tool.description, rawShape, tool.handler);
-        this.logger.info(`Registered tool: ${tool.name}`);
+        // Store tool definition for later registration with per-session servers
+        this.registeredTools.push({
+            name: tool.name,
+            description: tool.description,
+            schema: rawShape,
+            handler: tool.handler
+        });
+        this.logger.info(`Registered tool definition: ${tool.name}`);
     }
     /**
      * Configure Express server with Streamable HTTP and SSE endpoints
@@ -33737,7 +33814,7 @@ let McpService = class McpService {
             res.status(200).json({
                 status: 'ok',
                 server: 'Tabby MCP',
-                version: '1.1.3',
+                version: version_1.PLUGIN_VERSION,
                 transport: 'StreamableHTTP + SSE',
                 uptime: process.uptime()
             });
@@ -33746,7 +33823,7 @@ let McpService = class McpService {
         this.app.get('/info', (_, res) => {
             res.status(200).json({
                 name: 'Tabby MCP',
-                version: '1.1.3',
+                version: version_1.PLUGIN_VERSION,
                 protocolVersion: '2025-03-26',
                 transports: ['streamable-http', 'sse'],
                 endpoints: {
@@ -33855,11 +33932,13 @@ let McpService = class McpService {
                         this.logger.info(`Streamable HTTP: Transport closed (onclose): ${sessionId}`);
                         delete this.streamableTransports[sessionId];
                         this.sessionMetadata.delete(sessionId);
+                        this.cleanupServerForSession(sessionId); // Clean up the per-session server
                     };
                     this.streamableTransports[sessionId] = transport;
                     this.initSessionMetadata(sessionId, 'streamable', req);
-                    // Connect to MCP server
-                    await this.server.connect(transport);
+                    // Create per-session McpServer and connect to transport
+                    const server = this.createServerForSession(sessionId);
+                    await server.connect(transport);
                     this.logger.info(`Streamable HTTP: New session created: ${sessionId}`);
                 }
                 // Set session ID header in response
@@ -33927,14 +34006,18 @@ let McpService = class McpService {
                     clearInterval(heartbeatInterval);
                     delete this.legacyTransports[sessionId];
                     this.sessionMetadata.delete(sessionId);
+                    this.cleanupServerForSession(sessionId); // Clean up the per-session server
                 });
                 res.on('error', (err) => {
                     this.logger.error(`Legacy SSE: Connection error sessionId=${sessionId}`, err);
                     clearInterval(heartbeatInterval);
                     delete this.legacyTransports[sessionId];
                     this.sessionMetadata.delete(sessionId);
+                    this.cleanupServerForSession(sessionId); // Clean up the per-session server
                 });
-                await this.server.connect(transport);
+                // Create per-session McpServer and connect to transport
+                const server = this.createServerForSession(sessionId);
+                await server.connect(transport);
             }
             catch (error) {
                 this.logger.error('Legacy SSE: Failed to establish connection:', error);
@@ -34098,6 +34181,9 @@ let McpService = class McpService {
                 }
             }
             this.streamableTransports = {};
+            // Clear all per-session servers
+            this.sessionServers = {};
+            this.logger.debug('Cleared all per-session McpServer instances');
             // Force close all active connections
             if (this.sockets.size > 0) {
                 this.logger.info(`Closing ${this.sockets.size} active connections`);
@@ -34355,8 +34441,11 @@ let SFTPToolCategory = class SFTPToolCategory extends base_tool_category_1.BaseT
         this.config = config;
         this.terminalTools = terminalTools;
         this.name = 'sftp';
-        // Cache SFTP sessions to avoid reopening
-        this.sftpSessionCache = new WeakMap();
+        // Cache SFTP sessions with TTL and SSH session reference
+        // Key: sshSession object (using Map because we need to iterate for cleanup)
+        // Value: { sftpSession, createdAt } - createdAt for TTL expiration
+        this.sftpSessionCache = new Map();
+        this.SFTP_SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes TTL
         // Note: Session IDs are now managed by TerminalToolCategory for consistency
         // Transfer task queue
         this.transferTasks = new Map();
@@ -34412,6 +34501,57 @@ let SFTPToolCategory = class SFTPToolCategory extends base_tool_category_1.BaseT
             this.emitTransferUpdate();
         }
     }
+    /**
+     * Wait for transfer to complete with a polling fallback.
+     *
+     * Tabby's SFTP API (based on russh) may not always resolve the Promise
+     * even when the transfer is complete. This method uses Promise.race to
+     * detect completion via polling the isComplete() method.
+     *
+     * Also checks for SSH session disconnection to prevent infinite waits.
+     *
+     * @param sftpPromise - The original sftpSession.upload/download promise
+     * @param transferObj - StreamFileUpload or StreamFileDownload with isComplete()
+     * @param sshSession - Optional SSH session to check for disconnection
+     * @param pollIntervalMs - How often to check isComplete()
+     * @param maxWaitMs - Maximum time to wait before timing out (0 = no timeout)
+     */
+    async waitForTransferComplete(sftpPromise, transferObj, sshSession, pollIntervalMs = 500, maxWaitMs = 0) {
+        const startTime = Date.now();
+        // Create a polling promise that resolves when transfer is complete
+        const pollingPromise = new Promise((resolve, reject) => {
+            const checkComplete = () => {
+                // Check if SSH session disconnected
+                if (sshSession && sshSession.open === false) {
+                    this.logger.warn('[SFTP] SSH session disconnected during transfer');
+                    reject(new Error('SSH connection lost during transfer'));
+                    return;
+                }
+                // Check if cancelled
+                if (transferObj.isCancelled()) {
+                    reject(new Error('Transfer cancelled'));
+                    return;
+                }
+                // Check if complete
+                if (transferObj.isComplete()) {
+                    this.logger.debug('[SFTP] Transfer detected as complete via polling');
+                    resolve('completed_via_polling');
+                    return;
+                }
+                // Check timeout (if maxWaitMs > 0)
+                if (maxWaitMs > 0 && (Date.now() - startTime) > maxWaitMs) {
+                    reject(new Error(`Transfer timed out after ${maxWaitMs}ms`));
+                    return;
+                }
+                // Continue polling
+                setTimeout(checkComplete, pollIntervalMs);
+            };
+            // Start polling with a slight delay to let the native promise resolve first
+            setTimeout(checkComplete, pollIntervalMs);
+        });
+        // Race between the original promise and our polling promise
+        return Promise.race([sftpPromise, pollingPromise]);
+    }
     // ============== Public methods for UI ==============
     /** Get current snapshot of all transfers */
     getTransfers() {
@@ -34559,31 +34699,87 @@ let SFTPToolCategory = class SFTPToolCategory extends base_tool_category_1.BaseT
         try {
             const sshSession = sshTab.sshSession;
             if (!sshSession) {
+                this.logger.debug('[getSFTPSession] No sshSession on tab');
                 return null;
             }
-            // Key the cache by the actual SSH Session object, not the Tab.
-            // This ensures that if the Tab reconnects (getting a new sshSession object),
-            // we automatically get a cache miss and create a new SFTP session.
-            // Old cached sessions will be garbage collected when the old sshSession is destroyed.
-            const cached = this.sftpSessionCache.get(sshSession);
-            if (cached) {
-                return cached;
-            }
+            // Check if SSH session itself is still open
             if (!sshSession.open) {
+                this.logger.debug('[getSFTPSession] sshSession.open is false');
+                // Clear any stale cache entry
+                this.sftpSessionCache.delete(sshSession);
                 return null;
             }
+            // Check cache first
+            const cached = this.sftpSessionCache.get(sshSession);
+            if (cached) {
+                const age = Date.now() - cached.createdAt;
+                // Check TTL expiration (proactive cleanup before issues occur)
+                if (age > this.SFTP_SESSION_TTL_MS) {
+                    this.logger.info(`[getSFTPSession] SFTP session expired (age: ${Math.round(age / 1000)}s > TTL: ${this.SFTP_SESSION_TTL_MS / 1000}s). Recreating...`);
+                    this.sftpSessionCache.delete(sshSession);
+                    // Fall through to create new session
+                }
+                else {
+                    // CRITICAL: Validate cached session is still alive
+                    // Even within TTL, network issues can cause session to become stale
+                    try {
+                        // Quick health check with a lightweight operation
+                        await Promise.race([
+                            cached.sftpSession.stat('/'),
+                            new Promise((_, reject) => setTimeout(() => reject(new Error('SFTP health check timeout')), 3000))
+                        ]);
+                        this.logger.debug(`[getSFTPSession] Cached SFTP session validated (age: ${Math.round(age / 1000)}s)`);
+                        return cached.sftpSession;
+                    }
+                    catch (healthError) {
+                        // Cached session is stale/broken, remove and recreate
+                        this.logger.warn(`[getSFTPSession] Cached SFTP session failed health check: ${healthError.message}. Recreating...`);
+                        this.sftpSessionCache.delete(sshSession);
+                        // Fall through to create new session
+                    }
+                }
+            }
+            // Check if openSFTP is available
             if (typeof sshSession.openSFTP !== 'function') {
+                this.logger.debug('[getSFTPSession] sshSession.openSFTP is not a function');
                 return null;
             }
+            // Create new SFTP session
+            this.logger.debug('[getSFTPSession] Opening new SFTP session...');
             const sftpSession = await sshSession.openSFTP();
-            this.sftpSessionCache.set(sshSession, sftpSession);
+            // Store with creation timestamp for TTL management
+            this.sftpSessionCache.set(sshSession, {
+                sftpSession,
+                createdAt: Date.now()
+            });
+            this.logger.info('[getSFTPSession] New SFTP session opened and cached');
+            // Cleanup old entries from disconnected sessions
+            this.cleanupStaleSFTPSessions();
             return sftpSession;
         }
         catch (error) {
-            this.logger.error('Failed to open SFTP session:', error.message || error);
+            this.logger.error('[getSFTPSession] Failed to open SFTP session:', error.message || error);
             return null;
         }
     }
+    /**
+     * Cleanup stale SFTP sessions from closed SSH connections
+     * Called periodically when creating new sessions
+     */
+    cleanupStaleSFTPSessions() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [sshSession, cached] of this.sftpSessionCache.entries()) {
+            // Remove if SSH session is closed OR TTL expired
+            if (sshSession.open === false || (now - cached.createdAt) > this.SFTP_SESSION_TTL_MS) {
+                this.sftpSessionCache.delete(sshSession);
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            this.logger.debug(`[cleanupStaleSFTPSessions] Removed ${cleaned} stale entries`);
+        }
+    }
     // ============== BASIC SFTP OPERATIONS ==============
     createListFilesTool() {
         return {
@@ -35000,7 +35196,14 @@ Max upload size is configurable in Tabby Settings → MCP → SFTP.`,
                             task.progress = Math.round((bytes / task.totalBytes) * 100);
                             task.speed = bytes / ((Date.now() - task.startTime) / 1000);
                         });
-                        await sftpSession.upload(params.remotePath, fileUpload);
+                        // Wrap with polling fallback to handle Tabby SFTP API not resolving
+                        // Also pass sshSession to detect connection loss during transfer
+                        const sshSession = session.tab.sshSession;
+                        const uploadPromise = sftpSession.upload(params.remotePath, fileUpload);
+                        const result = await this.waitForTransferComplete(uploadPromise, fileUpload, sshSession);
+                        if (result === 'completed_via_polling') {
+                            this.logger.info(`[sftp_upload] Transfer completed via polling fallback`);
+                        }
                         task.status = 'completed';
                         task.progress = 100;
                         task.bytesTransferred = task.totalBytes;
@@ -35180,7 +35383,14 @@ Max download size is configurable in Tabby Settings → MCP → SFTP.`,
                                 task.progress = Math.round((bytes / task.totalBytes) * 100);
                                 task.speed = bytes / ((Date.now() - task.startTime) / 1000);
                             });
-                            await sftpSession.download(params.remotePath, fileDownload);
+                            // Wrap with polling fallback to handle Tabby SFTP API not resolving
+                            // Also pass sshSession to detect connection loss during transfer
+                            const sshSession = session.tab.sshSession;
+                            const downloadPromise = sftpSession.download(params.remotePath, fileDownload);
+                            const result = await this.waitForTransferComplete(downloadPromise, fileDownload, sshSession);
+                            if (result === 'completed_via_polling') {
+                                this.logger.info(`[sftp_download] Transfer completed via polling fallback`);
+                            }
                             task.status = 'completed';
                             task.progress = 100;
                             task.bytesTransferred = task.totalBytes;
@@ -38202,6 +38412,14 @@ module.exports = require("node:crypto");
 
 /***/ },
 
+/***/ 1692
+(module) {
+
+"use strict";
+module.exports = require("node:tls");
+
+/***/ },
+
 /***/ 3136
 (module) {
 
@@ -38419,7 +38637,7 @@ exports.ExperimentalMcpServerTasks = ExperimentalMcpServerTasks;
 /***/ },
 
 /***/ 3200
-(__unused_webpack_module, exports) {
+(__unused_webpack_module, exports, __webpack_require__) {
 
 "use strict";
 
@@ -38431,6 +38649,7 @@ exports.ExperimentalMcpServerTasks = ExperimentalMcpServerTasks;
  */
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.ExperimentalServerTasks = void 0;
+const types_js_1 = __webpack_require__(1294);
 /**
  * Experimental task features for low-level MCP servers.
  *
@@ -38464,6 +38683,162 @@ class ExperimentalServerTasks {
     requestStream(request, resultSchema, options) {
         return this._server.requestStream(request, resultSchema, options);
     }
+    /**
+     * Sends a sampling request and returns an AsyncGenerator that yields response messages.
+     * The generator is guaranteed to end with either a 'result' or 'error' message.
+     *
+     * For task-augmented requests, yields 'taskCreated' and 'taskStatus' messages
+     * before the final result.
+     *
+     * @example
+     * ```typescript
+     * const stream = server.experimental.tasks.createMessageStream({
+     *     messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
+     *     maxTokens: 100
+     * }, {
+     *     onprogress: (progress) => {
+     *         // Handle streaming tokens via progress notifications
+     *         console.log('Progress:', progress.message);
+     *     }
+     * });
+     *
+     * for await (const message of stream) {
+     *     switch (message.type) {
+     *         case 'taskCreated':
+     *             console.log('Task created:', message.task.taskId);
+     *             break;
+     *         case 'taskStatus':
+     *             console.log('Task status:', message.task.status);
+     *             break;
+     *         case 'result':
+     *             console.log('Final result:', message.result);
+     *             break;
+     *         case 'error':
+     *             console.error('Error:', message.error);
+     *             break;
+     *     }
+     * }
+     * ```
+     *
+     * @param params - The sampling request parameters
+     * @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)
+     * @returns AsyncGenerator that yields ResponseMessage objects
+     *
+     * @experimental
+     */
+    createMessageStream(params, options) {
+        // Access client capabilities via the server
+        const clientCapabilities = this._server.getClientCapabilities();
+        // Capability check - only required when tools/toolChoice are provided
+        if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {
+            throw new Error('Client does not support sampling tools capability.');
+        }
+        // Message structure validation - always validate tool_use/tool_result pairs.
+        // These may appear even without tools/toolChoice in the current request when
+        // a previous sampling request returned tool_use and this is a follow-up with results.
+        if (params.messages.length > 0) {
+            const lastMessage = params.messages[params.messages.length - 1];
+            const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+            const hasToolResults = lastContent.some(c => c.type === 'tool_result');
+            const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : undefined;
+            const previousContent = previousMessage
+                ? Array.isArray(previousMessage.content)
+                    ? previousMessage.content
+                    : [previousMessage.content]
+                : [];
+            const hasPreviousToolUse = previousContent.some(c => c.type === 'tool_use');
+            if (hasToolResults) {
+                if (lastContent.some(c => c.type !== 'tool_result')) {
+                    throw new Error('The last message must contain only tool_result content if any is present');
+                }
+                if (!hasPreviousToolUse) {
+                    throw new Error('tool_result blocks are not matching any tool_use from the previous message');
+                }
+            }
+            if (hasPreviousToolUse) {
+                // Extract tool_use IDs from previous message and tool_result IDs from current message
+                const toolUseIds = new Set(previousContent.filter(c => c.type === 'tool_use').map(c => c.id));
+                const toolResultIds = new Set(lastContent.filter(c => c.type === 'tool_result').map(c => c.toolUseId));
+                if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every(id => toolResultIds.has(id))) {
+                    throw new Error('ids of tool_result blocks and tool_use blocks from previous message do not match');
+                }
+            }
+        }
+        return this.requestStream({
+            method: 'sampling/createMessage',
+            params
+        }, types_js_1.CreateMessageResultSchema, options);
+    }
+    /**
+     * Sends an elicitation request and returns an AsyncGenerator that yields response messages.
+     * The generator is guaranteed to end with either a 'result' or 'error' message.
+     *
+     * For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'
+     * and 'taskStatus' messages before the final result.
+     *
+     * @example
+     * ```typescript
+     * const stream = server.experimental.tasks.elicitInputStream({
+     *     mode: 'url',
+     *     message: 'Please authenticate',
+     *     elicitationId: 'auth-123',
+     *     url: 'https://example.com/auth'
+     * }, {
+     *     task: { ttl: 300000 } // Task-augmented for long-running auth flow
+     * });
+     *
+     * for await (const message of stream) {
+     *     switch (message.type) {
+     *         case 'taskCreated':
+     *             console.log('Task created:', message.task.taskId);
+     *             break;
+     *         case 'taskStatus':
+     *             console.log('Task status:', message.task.status);
+     *             break;
+     *         case 'result':
+     *             console.log('User action:', message.result.action);
+     *             break;
+     *         case 'error':
+     *             console.error('Error:', message.error);
+     *             break;
+     *     }
+     * }
+     * ```
+     *
+     * @param params - The elicitation request parameters
+     * @param options - Optional request options (timeout, signal, task creation params, etc.)
+     * @returns AsyncGenerator that yields ResponseMessage objects
+     *
+     * @experimental
+     */
+    elicitInputStream(params, options) {
+        // Access client capabilities via the server
+        const clientCapabilities = this._server.getClientCapabilities();
+        const mode = params.mode ?? 'form';
+        // Capability check based on mode
+        switch (mode) {
+            case 'url': {
+                if (!clientCapabilities?.elicitation?.url) {
+                    throw new Error('Client does not support url elicitation.');
+                }
+                break;
+            }
+            case 'form': {
+                if (!clientCapabilities?.elicitation?.form) {
+                    throw new Error('Client does not support form elicitation.');
+                }
+                break;
+            }
+        }
+        // Normalize params to ensure mode is set for form mode (defaults to 'form' per spec)
+        const normalizedParams = mode === 'form' && params.mode === undefined ? { ...params, mode: 'form' } : params;
+        // Cast to ServerRequest needed because TypeScript can't narrow the union type
+        // based on the discriminated 'method' field when constructing the object literal
+        return this.requestStream({
+            method: 'elicitation/create',
+            params: normalizedParams
+        }, types_js_1.ElicitResultSchema, options);
+    }
     /**
      * Gets the current status of a task.
      *
@@ -39960,6 +40335,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.SSEServerTransport = void 0;
 const node_crypto_1 = __webpack_require__(5217);
+const node_tls_1 = __webpack_require__(1692);
 const types_js_1 = __webpack_require__(1294);
 const raw_body_1 = __importDefault(__webpack_require__(7680));
 const content_type_1 = __importDefault(__webpack_require__(8597));
@@ -40054,7 +40430,13 @@ class SSEServerTransport {
             return;
         }
         const authInfo = req.auth;
-        const requestInfo = { headers: req.headers };
+        const host = req.headers.host;
+        const protocol = req.socket instanceof node_tls_1.TLSSocket ? 'https' : 'http';
+        const fullUrl = host && req.url ? new node_url_1.URL(req.url, `${protocol}://${host}`) : undefined;
+        const requestInfo = {
+            headers: req.headers,
+            url: fullUrl
+        };
         let body;
         try {
             const ct = content_type_1.default.parse(req.headers['content-type'] ?? '');
@@ -40355,6 +40737,7 @@ const types_js_1 = __webpack_require__(1294);
 class WebStandardStreamableHTTPServerTransport {
     constructor(options = {}) {
         this._started = false;
+        this._hasHandledRequest = false;
         this._streamMapping = new Map();
         this._requestToStreamMapping = new Map();
         this._requestResponseMap = new Map();
@@ -40435,6 +40818,12 @@ class WebStandardStreamableHTTPServerTransport {
      * Returns a Response object (Web Standard)
      */
     async handleRequest(req, options) {
+        // In stateless mode (no sessionIdGenerator), each request must use a fresh transport.
+        // Reusing a stateless transport causes message ID collisions between clients.
+        if (!this.sessionIdGenerator && this._hasHandledRequest) {
+            throw new Error('Stateless transport cannot be reused across requests. Create a new transport per request.');
+        }
+        this._hasHandledRequest = true;
         // Validate request headers for DNS rebinding protection
         const validationError = this.validateRequestHeaders(req);
         if (validationError) {
@@ -40480,6 +40869,7 @@ class WebStandardStreamableHTTPServerTransport {
         // The client MUST include an Accept header, listing text/event-stream as a supported content type.
         const acceptHeader = req.headers.get('accept');
         if (!acceptHeader?.includes('text/event-stream')) {
+            this.onerror?.(new Error('Not Acceptable: Client must accept text/event-stream'));
             return this.createJsonErrorResponse(406, -32000, 'Not Acceptable: Client must accept text/event-stream');
         }
         // If an Mcp-Session-Id is returned by the server during initialization,
@@ -40503,6 +40893,7 @@ class WebStandardStreamableHTTPServerTransport {
         // Check if there's already an active standalone SSE stream for this session
         if (this._streamMapping.get(this._standaloneSseStreamId) !== undefined) {
             // Only one GET SSE stream is allowed per session
+            this.onerror?.(new Error('Conflict: Only one SSE stream is allowed per session'));
             return this.createJsonErrorResponse(409, -32000, 'Conflict: Only one SSE stream is allowed per session');
         }
         const encoder = new TextEncoder();
@@ -40548,6 +40939,7 @@ class WebStandardStreamableHTTPServerTransport {
      */
     async replayEvents(lastEventId) {
         if (!this._eventStore) {
+            this.onerror?.(new Error('Event store not configured'));
             return this.createJsonErrorResponse(400, -32000, 'Event store not configured');
         }
         try {
@@ -40556,10 +40948,12 @@ class WebStandardStreamableHTTPServerTransport {
             if (this._eventStore.getStreamIdForEventId) {
                 streamId = await this._eventStore.getStreamIdForEventId(lastEventId);
                 if (!streamId) {
+                    this.onerror?.(new Error('Invalid event ID format'));
                     return this.createJsonErrorResponse(400, -32000, 'Invalid event ID format');
                 }
                 // Check conflict with the SAME streamId we'll use for mapping
                 if (this._streamMapping.get(streamId) !== undefined) {
+                    this.onerror?.(new Error('Conflict: Stream already has an active connection'));
                     return this.createJsonErrorResponse(409, -32000, 'Conflict: Stream already has an active connection');
                 }
             }
@@ -40632,7 +41026,8 @@ class WebStandardStreamableHTTPServerTransport {
             controller.enqueue(encoder.encode(eventData));
             return true;
         }
-        catch {
+        catch (error) {
+            this.onerror?.(error);
             return false;
         }
     }
@@ -40640,6 +41035,7 @@ class WebStandardStreamableHTTPServerTransport {
      * Handles unsupported requests (PUT, PATCH, etc.)
      */
     handleUnsupportedRequest() {
+        this.onerror?.(new Error('Method not allowed.'));
         return new Response(JSON.stringify({
             jsonrpc: '2.0',
             error: {
@@ -40664,15 +41060,18 @@ class WebStandardStreamableHTTPServerTransport {
             const acceptHeader = req.headers.get('accept');
             // The client MUST include an Accept header, listing both application/json and text/event-stream as supported content types.
             if (!acceptHeader?.includes('application/json') || !acceptHeader.includes('text/event-stream')) {
+                this.onerror?.(new Error('Not Acceptable: Client must accept both application/json and text/event-stream'));
                 return this.createJsonErrorResponse(406, -32000, 'Not Acceptable: Client must accept both application/json and text/event-stream');
             }
             const ct = req.headers.get('content-type');
             if (!ct || !ct.includes('application/json')) {
+                this.onerror?.(new Error('Unsupported Media Type: Content-Type must be application/json'));
                 return this.createJsonErrorResponse(415, -32000, 'Unsupported Media Type: Content-Type must be application/json');
             }
-            // Build request info from headers
+            // Build request info from headers and URL
             const requestInfo = {
-                headers: Object.fromEntries(req.headers.entries())
+                headers: Object.fromEntries(req.headers.entries()),
+                url: new URL(req.url)
             };
             let rawMessage;
             if (options?.parsedBody !== undefined) {
@@ -40683,6 +41082,7 @@ class WebStandardStreamableHTTPServerTransport {
                     rawMessage = await req.json();
                 }
                 catch {
+                    this.onerror?.(new Error('Parse error: Invalid JSON'));
                     return this.createJsonErrorResponse(400, -32700, 'Parse error: Invalid JSON');
                 }
             }
@@ -40697,6 +41097,7 @@ class WebStandardStreamableHTTPServerTransport {
                 }
             }
             catch {
+                this.onerror?.(new Error('Parse error: Invalid JSON-RPC message'));
                 return this.createJsonErrorResponse(400, -32700, 'Parse error: Invalid JSON-RPC message');
             }
             // Check if this is an initialization request
@@ -40706,9 +41107,11 @@ class WebStandardStreamableHTTPServerTransport {
                 // If it's a server with session management and the session ID is already set we should reject the request
                 // to avoid re-initialization.
                 if (this._initialized && this.sessionId !== undefined) {
+                    this.onerror?.(new Error('Invalid Request: Server already initialized'));
                     return this.createJsonErrorResponse(400, -32600, 'Invalid Request: Server already initialized');
                 }
                 if (messages.length > 1) {
+                    this.onerror?.(new Error('Invalid Request: Only one initialization request is allowed'));
                     return this.createJsonErrorResponse(400, -32600, 'Invalid Request: Only one initialization request is allowed');
                 }
                 this.sessionId = this.sessionIdGenerator?.();
@@ -40870,15 +41273,18 @@ class WebStandardStreamableHTTPServerTransport {
         }
         if (!this._initialized) {
             // If the server has not been initialized yet, reject all requests
+            this.onerror?.(new Error('Bad Request: Server not initialized'));
             return this.createJsonErrorResponse(400, -32000, 'Bad Request: Server not initialized');
         }
         const sessionId = req.headers.get('mcp-session-id');
         if (!sessionId) {
             // Non-initialization requests without a session ID should return 400 Bad Request
+            this.onerror?.(new Error('Bad Request: Mcp-Session-Id header is required'));
             return this.createJsonErrorResponse(400, -32000, 'Bad Request: Mcp-Session-Id header is required');
         }
         if (sessionId !== this.sessionId) {
             // Reject requests with invalid session ID with 404 Not Found
+            this.onerror?.(new Error('Session not found'));
             return this.createJsonErrorResponse(404, -32001, 'Session not found');
         }
         return undefined;
@@ -40899,6 +41305,8 @@ class WebStandardStreamableHTTPServerTransport {
     validateProtocolVersion(req) {
         const protocolVersion = req.headers.get('mcp-protocol-version');
         if (protocolVersion !== null && !types_js_1.SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {
+            this.onerror?.(new Error(`Bad Request: Unsupported protocol version: ${protocolVersion}` +
+                ` (supported versions: ${types_js_1.SUPPORTED_PROTOCOL_VERSIONS.join(', ')})`));
             return this.createJsonErrorResponse(400, -32000, `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${types_js_1.SUPPORTED_PROTOCOL_VERSIONS.join(', ')})`);
         }
         return undefined;
@@ -41589,6 +41997,9 @@ class Protocol {
      * The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
      */
     async connect(transport) {
+        if (this._transport) {
+            throw new Error('Already connected to a transport. Call close() before connecting to a new transport, or use a separate Protocol instance per connection.');
+        }
         this._transport = transport;
         const _onclose = this.transport?.onclose;
         this._transport.onclose = () => {
@@ -41624,6 +42035,11 @@ class Protocol {
         this._progressHandlers.clear();
         this._taskProgressTokens.clear();
         this._pendingDebouncedNotifications.clear();
+        // Abort all in-flight request handlers so they stop sending messages
+        for (const controller of this._requestHandlerAbortControllers.values()) {
+            controller.abort();
+        }
+        this._requestHandlerAbortControllers.clear();
         const error = types_js_1.McpError.fromError(types_js_1.ErrorCode.ConnectionClosed, 'Connection closed');
         this._transport = undefined;
         this.onclose?.();
@@ -41684,6 +42100,8 @@ class Protocol {
             sessionId: capturedTransport?.sessionId,
             _meta: request.params?._meta,
             sendNotification: async (notification) => {
+                if (abortController.signal.aborted)
+                    return;
                 // Include related-task metadata if this request is part of a task
                 const notificationOptions = { relatedRequestId: request.id };
                 if (relatedTaskId) {
@@ -41692,6 +42110,9 @@ class Protocol {
                 await this.notification(notification, notificationOptions);
             },
             sendRequest: async (r, resultSchema, options) => {
+                if (abortController.signal.aborted) {
+                    throw new types_js_1.McpError(types_js_1.ErrorCode.ConnectionClosed, 'Request was cancelled');
+                }
                 // Include related-task metadata if this request is part of a task
                 const requestOptions = { ...options, relatedRequestId: request.id };
                 if (relatedTaskId && !requestOptions.relatedTask) {
@@ -67079,7 +67500,7 @@ module.exports = /*#__PURE__*/JSON.parse('{"100":"Continue","101":"Switching Pro
 (module) {
 
 "use strict";
-module.exports = /*#__PURE__*/JSON.parse('{"name":"tabby-mcp-server","version":"1.3.0","description":"MCP (Model Context Protocol) server plugin for Tabby terminal - Complete terminal control with 34 MCP tools including SFTP file transfer","homepage":"https://github.com/GentlemanHu/Tabby-MCP","repository":{"type":"git","url":"https://github.com/GentlemanHu/Tabby-MCP.git"},"bugs":{"url":"https://github.com/GentlemanHu/Tabby-MCP/issues"},"keywords":["tabby-plugin","mcp","model-context-protocol","terminal","ai","cursor","windsurf","ssh","sftp","sse"],"main":"dist/index.js","typings":"typings/index.d.ts","scripts":{"build":"webpack --progress --color","watch":"webpack --progress --color --watch","install-plugin":"bash scripts/install.sh","uninstall-plugin":"bash scripts/uninstall.sh"},"files":["dist","typings"],"author":"GentlemanHu <justfeelingme@gmail.com>","contributors":["AI Assistant (Claude/Gemini)"],"license":"MIT","peerDependencies":{"@angular/animations":"*","@angular/common":"*","@angular/core":"*","@angular/forms":"*","@ng-bootstrap/ng-bootstrap":"*","rxjs":"*","tabby-core":"*","tabby-settings":"*","tabby-terminal":"*","tabby-ssh":"*"},"peerDependenciesMeta":{"tabby-ssh":{"optional":true},"@angular/animations":{"optional":true},"@angular/common":{"optional":true},"@angular/core":{"optional":true},"@angular/forms":{"optional":true},"@ng-bootstrap/ng-bootstrap":{"optional":true},"rxjs":{"optional":true},"tabby-core":{"optional":true},"tabby-settings":{"optional":true},"tabby-terminal":{"optional":true}},"devDependencies":{"@modelcontextprotocol/sdk":"^1.8.0","@xterm/addon-serialize":"^0.12.0","cors":"^2.8.5","express":"^4.18.2","zod":"^3.22.4","@angular/common":"^17.3.0","@angular/core":"^17.3.0","@angular/forms":"^17.3.0","@angular/animations":"^17.3.0","@angular/platform-browser":"^17.3.0","@ng-bootstrap/ng-bootstrap":"^16.0.0","rxjs":"^7.8.0","tabby-core":"^1.0.163","tabby-settings":"^1.0.163","tabby-ssh":"^1.0.163","tabby-terminal":"^1.0.163","@types/cors":"^2.8.17","@types/express":"^4.17.21","@types/node":"^20.10.0","apply-loader":"^2.0.0","css-loader":"^6.8.1","sass":"^1.69.0","sass-loader":"^13.3.2","strip-ansi":"^7.1.0","style-loader":"^3.3.3","ts-loader":"^9.5.0","typescript":"^5.3.0","webpack":"^5.89.0","webpack-cli":"^5.1.4"}}');
+module.exports = /*#__PURE__*/JSON.parse('{"name":"tabby-mcp-server","version":"1.4.2","description":"MCP (Model Context Protocol) server plugin for Tabby terminal - Complete terminal control with 34 MCP tools including SFTP file transfer","homepage":"https://github.com/GentlemanHu/Tabby-MCP","repository":{"type":"git","url":"https://github.com/GentlemanHu/Tabby-MCP.git"},"bugs":{"url":"https://github.com/GentlemanHu/Tabby-MCP/issues"},"keywords":["tabby-plugin","mcp","model-context-protocol","terminal","ai","cursor","windsurf","ssh","sftp","sse"],"main":"dist/index.js","typings":"typings/index.d.ts","scripts":{"build":"webpack --progress --color","watch":"webpack --progress --color --watch","install-plugin":"bash scripts/install.sh","uninstall-plugin":"bash scripts/uninstall.sh"},"files":["dist","typings"],"author":"GentlemanHu <justfeelingme@gmail.com>","contributors":["AI Assistant (Claude/Gemini)"],"license":"MIT","peerDependencies":{"@angular/animations":"*","@angular/common":"*","@angular/core":"*","@angular/forms":"*","@ng-bootstrap/ng-bootstrap":"*","rxjs":"*","tabby-core":"*","tabby-settings":"*","tabby-terminal":"*","tabby-ssh":"*"},"peerDependenciesMeta":{"tabby-ssh":{"optional":true},"@angular/animations":{"optional":true},"@angular/common":{"optional":true},"@angular/core":{"optional":true},"@angular/forms":{"optional":true},"@ng-bootstrap/ng-bootstrap":{"optional":true},"rxjs":{"optional":true},"tabby-core":{"optional":true},"tabby-settings":{"optional":true},"tabby-terminal":{"optional":true}},"devDependencies":{"@modelcontextprotocol/sdk":"^1.8.0","@xterm/addon-serialize":"^0.12.0","cors":"^2.8.5","express":"^4.18.2","zod":"^3.22.4","@angular/common":"^17.3.0","@angular/core":"^17.3.0","@angular/forms":"^17.3.0","@angular/animations":"^17.3.0","@angular/platform-browser":"^17.3.0","@ng-bootstrap/ng-bootstrap":"^16.0.0","rxjs":"^7.8.0","tabby-core":"^1.0.163","tabby-settings":"^1.0.163","tabby-ssh":"^1.0.163","tabby-terminal":"^1.0.163","@types/cors":"^2.8.17","@types/express":"^4.17.21","@types/node":"^20.10.0","apply-loader":"^2.0.0","css-loader":"^6.8.1","sass":"^1.69.0","sass-loader":"^13.3.2","strip-ansi":"^7.1.0","style-loader":"^3.3.3","ts-loader":"^9.5.0","typescript":"^5.3.0","webpack":"^5.89.0","webpack-cli":"^5.1.4"}}');
 
 /***/ },