@qqbrowser/openclaw-qbot 0.10.17 → 0.10.19

package/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/middleware.js

@@ -1,252 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMiddleware = exports.applyMiddlewares = exports.withLogging = exports.withOAuth = void 0;
-const auth_js_1 = require("./auth.js");
-/**
- * Creates a fetch wrapper that handles OAuth authentication automatically.
- *
- * This wrapper will:
- * - Add Authorization headers with access tokens
- * - Handle 401 responses by attempting re-authentication
- * - Retry the original request after successful auth
- * - Handle OAuth errors appropriately (InvalidClientError, etc.)
- *
- * The baseUrl parameter is optional and defaults to using the domain from the request URL.
- * However, you should explicitly provide baseUrl when:
- * - Making requests to multiple subdomains (e.g., api.example.com, cdn.example.com)
- * - Using API paths that differ from OAuth discovery paths (e.g., requesting /api/v1/data but OAuth is at /)
- * - The OAuth server is on a different domain than your API requests
- * - You want to ensure consistent OAuth behavior regardless of request URLs
- *
- * For MCP transports, set baseUrl to the same URL you pass to the transport constructor.
- *
- * Note: This wrapper is designed for general-purpose fetch operations.
- * MCP transports (SSE and StreamableHTTP) already have built-in OAuth handling
- * and should not need this wrapper.
- *
- * @param provider - OAuth client provider for authentication
- * @param baseUrl - Base URL for OAuth server discovery (defaults to request URL domain)
- * @returns A fetch middleware function
- */
-const withOAuth = (provider, baseUrl) => next => {
-    return async (input, init) => {
-        const makeRequest = async () => {
-            const headers = new Headers(init?.headers);
-            // Add authorization header if tokens are available
-            const tokens = await provider.tokens();
-            if (tokens) {
-                headers.set('Authorization', `Bearer ${tokens.access_token}`);
-            }
-            return await next(input, { ...init, headers });
-        };
-        let response = await makeRequest();
-        // Handle 401 responses by attempting re-authentication
-        if (response.status === 401) {
-            try {
-                const { resourceMetadataUrl, scope } = (0, auth_js_1.extractWWWAuthenticateParams)(response);
-                // Use provided baseUrl or extract from request URL
-                const serverUrl = baseUrl || (typeof input === 'string' ? new URL(input).origin : input.origin);
-                const result = await (0, auth_js_1.auth)(provider, {
-                    serverUrl,
-                    resourceMetadataUrl,
-                    scope,
-                    fetchFn: next
-                });
-                if (result === 'REDIRECT') {
-                    throw new auth_js_1.UnauthorizedError('Authentication requires user authorization - redirect initiated');
-                }
-                if (result !== 'AUTHORIZED') {
-                    throw new auth_js_1.UnauthorizedError(`Authentication failed with result: ${result}`);
-                }
-                // Retry the request with fresh tokens
-                response = await makeRequest();
-            }
-            catch (error) {
-                if (error instanceof auth_js_1.UnauthorizedError) {
-                    throw error;
-                }
-                throw new auth_js_1.UnauthorizedError(`Failed to re-authenticate: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        // If we still have a 401 after re-auth attempt, throw an error
-        if (response.status === 401) {
-            const url = typeof input === 'string' ? input : input.toString();
-            throw new auth_js_1.UnauthorizedError(`Authentication failed for ${url}`);
-        }
-        return response;
-    };
-};
-exports.withOAuth = withOAuth;
-/**
- * Creates a fetch middleware that logs HTTP requests and responses.
- *
- * When called without arguments `withLogging()`, it uses the default logger that:
- * - Logs successful requests (2xx) to `console.log`
- * - Logs error responses (4xx/5xx) and network errors to `console.error`
- * - Logs all requests regardless of status (statusLevel: 0)
- * - Does not include request or response headers in logs
- * - Measures and displays request duration in milliseconds
- *
- * Important: the default logger uses both `console.log` and `console.error` so it should not be used with
- * `stdio` transports and applications.
- *
- * @param options - Logging configuration options
- * @returns A fetch middleware function
- */
-const withLogging = (options = {}) => {
-    const { logger, includeRequestHeaders = false, includeResponseHeaders = false, statusLevel = 0 } = options;
-    const defaultLogger = input => {
-        const { method, url, status, statusText, duration, requestHeaders, responseHeaders, error } = input;
-        let message = error
-            ? `HTTP ${method} ${url} failed: ${error.message} (${duration}ms)`
-            : `HTTP ${method} ${url} ${status} ${statusText} (${duration}ms)`;
-        // Add headers to message if requested
-        if (includeRequestHeaders && requestHeaders) {
-            const reqHeaders = Array.from(requestHeaders.entries())
-                .map(([key, value]) => `${key}: ${value}`)
-                .join(', ');
-            message += `\n  Request Headers: {${reqHeaders}}`;
-        }
-        if (includeResponseHeaders && responseHeaders) {
-            const resHeaders = Array.from(responseHeaders.entries())
-                .map(([key, value]) => `${key}: ${value}`)
-                .join(', ');
-            message += `\n  Response Headers: {${resHeaders}}`;
-        }
-        if (error || status >= 400) {
-            // eslint-disable-next-line no-console
-            console.error(message);
-        }
-        else {
-            // eslint-disable-next-line no-console
-            console.log(message);
-        }
-    };
-    const logFn = logger || defaultLogger;
-    return next => async (input, init) => {
-        const startTime = performance.now();
-        const method = init?.method || 'GET';
-        const url = typeof input === 'string' ? input : input.toString();
-        const requestHeaders = includeRequestHeaders ? new Headers(init?.headers) : undefined;
-        try {
-            const response = await next(input, init);
-            const duration = performance.now() - startTime;
-            // Only log if status meets the log level threshold
-            if (response.status >= statusLevel) {
-                logFn({
-                    method,
-                    url,
-                    status: response.status,
-                    statusText: response.statusText,
-                    duration,
-                    requestHeaders,
-                    responseHeaders: includeResponseHeaders ? response.headers : undefined
-                });
-            }
-            return response;
-        }
-        catch (error) {
-            const duration = performance.now() - startTime;
-            // Always log errors regardless of log level
-            logFn({
-                method,
-                url,
-                status: 0,
-                statusText: 'Network Error',
-                duration,
-                requestHeaders,
-                error: error
-            });
-            throw error;
-        }
-    };
-};
-exports.withLogging = withLogging;
-/**
- * Composes multiple fetch middleware functions into a single middleware pipeline.
- * Middleware are applied in the order they appear, creating a chain of handlers.
- *
- * @example
- * ```typescript
- * // Create a middleware pipeline that handles both OAuth and logging
- * const enhancedFetch = applyMiddlewares(
- *   withOAuth(oauthProvider, 'https://api.example.com'),
- *   withLogging({ statusLevel: 400 })
- * )(fetch);
- *
- * // Use the enhanced fetch - it will handle auth and log errors
- * const response = await enhancedFetch('https://api.example.com/data');
- * ```
- *
- * @param middleware - Array of fetch middleware to compose into a pipeline
- * @returns A single composed middleware function
- */
-const applyMiddlewares = (...middleware) => {
-    return next => {
-        return middleware.reduce((handler, mw) => mw(handler), next);
-    };
-};
-exports.applyMiddlewares = applyMiddlewares;
-/**
- * Helper function to create custom fetch middleware with cleaner syntax.
- * Provides the next handler and request details as separate parameters for easier access.
- *
- * @example
- * ```typescript
- * // Create custom authentication middleware
- * const customAuthMiddleware = createMiddleware(async (next, input, init) => {
- *   const headers = new Headers(init?.headers);
- *   headers.set('X-Custom-Auth', 'my-token');
- *
- *   const response = await next(input, { ...init, headers });
- *
- *   if (response.status === 401) {
- *     console.log('Authentication failed');
- *   }
- *
- *   return response;
- * });
- *
- * // Create conditional middleware
- * const conditionalMiddleware = createMiddleware(async (next, input, init) => {
- *   const url = typeof input === 'string' ? input : input.toString();
- *
- *   // Only add headers for API routes
- *   if (url.includes('/api/')) {
- *     const headers = new Headers(init?.headers);
- *     headers.set('X-API-Version', 'v2');
- *     return next(input, { ...init, headers });
- *   }
- *
- *   // Pass through for non-API routes
- *   return next(input, init);
- * });
- *
- * // Create caching middleware
- * const cacheMiddleware = createMiddleware(async (next, input, init) => {
- *   const cacheKey = typeof input === 'string' ? input : input.toString();
- *
- *   // Check cache first
- *   const cached = await getFromCache(cacheKey);
- *   if (cached) {
- *     return new Response(cached, { status: 200 });
- *   }
- *
- *   // Make request and cache result
- *   const response = await next(input, init);
- *   if (response.ok) {
- *     await saveToCache(cacheKey, await response.clone().text());
- *   }
- *
- *   return response;
- * });
- * ```
- *
- * @param handler - Function that receives the next handler and request parameters
- * @returns A fetch middleware function
- */
-const createMiddleware = (handler) => {
-    return next => (input, init) => handler(next, input, init);
-};
-exports.createMiddleware = createMiddleware;
-//# sourceMappingURL=middleware.js.map

package/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/sse.js

@@ -1,211 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SSEClientTransport = exports.SseError = void 0;
-const eventsource_1 = require("eventsource");
-const transport_js_1 = require("../shared/transport.js");
-const types_js_1 = require("../types.js");
-const auth_js_1 = require("./auth.js");
-class SseError extends Error {
-    constructor(code, message, event) {
-        super(`SSE error: ${message}`);
-        this.code = code;
-        this.event = event;
-    }
-}
-exports.SseError = SseError;
-/**
- * Client transport for SSE: this will connect to a server using Server-Sent Events for receiving
- * messages and make separate POST requests for sending messages.
- * @deprecated SSEClientTransport is deprecated. Prefer to use StreamableHTTPClientTransport where possible instead. Note that because some servers are still using SSE, clients may need to support both transports during the migration period.
- */
-class SSEClientTransport {
-    constructor(url, opts) {
-        this._url = url;
-        this._resourceMetadataUrl = undefined;
-        this._scope = undefined;
-        this._eventSourceInit = opts?.eventSourceInit;
-        this._requestInit = opts?.requestInit;
-        this._authProvider = opts?.authProvider;
-        this._fetch = opts?.fetch;
-        this._fetchWithInit = (0, transport_js_1.createFetchWithInit)(opts?.fetch, opts?.requestInit);
-    }
-    async _authThenStart() {
-        if (!this._authProvider) {
-            throw new auth_js_1.UnauthorizedError('No auth provider');
-        }
-        let result;
-        try {
-            result = await (0, auth_js_1.auth)(this._authProvider, {
-                serverUrl: this._url,
-                resourceMetadataUrl: this._resourceMetadataUrl,
-                scope: this._scope,
-                fetchFn: this._fetchWithInit
-            });
-        }
-        catch (error) {
-            this.onerror?.(error);
-            throw error;
-        }
-        if (result !== 'AUTHORIZED') {
-            throw new auth_js_1.UnauthorizedError();
-        }
-        return await this._startOrAuth();
-    }
-    async _commonHeaders() {
-        const headers = {};
-        if (this._authProvider) {
-            const tokens = await this._authProvider.tokens();
-            if (tokens) {
-                headers['Authorization'] = `Bearer ${tokens.access_token}`;
-            }
-        }
-        if (this._protocolVersion) {
-            headers['mcp-protocol-version'] = this._protocolVersion;
-        }
-        const extraHeaders = (0, transport_js_1.normalizeHeaders)(this._requestInit?.headers);
-        return new Headers({
-            ...headers,
-            ...extraHeaders
-        });
-    }
-    _startOrAuth() {
-        const fetchImpl = (this?._eventSourceInit?.fetch ?? this._fetch ?? fetch);
-        return new Promise((resolve, reject) => {
-            this._eventSource = new eventsource_1.EventSource(this._url.href, {
-                ...this._eventSourceInit,
-                fetch: async (url, init) => {
-                    const headers = await this._commonHeaders();
-                    headers.set('Accept', 'text/event-stream');
-                    const response = await fetchImpl(url, {
-                        ...init,
-                        headers
-                    });
-                    if (response.status === 401 && response.headers.has('www-authenticate')) {
-                        const { resourceMetadataUrl, scope } = (0, auth_js_1.extractWWWAuthenticateParams)(response);
-                        this._resourceMetadataUrl = resourceMetadataUrl;
-                        this._scope = scope;
-                    }
-                    return response;
-                }
-            });
-            this._abortController = new AbortController();
-            this._eventSource.onerror = event => {
-                if (event.code === 401 && this._authProvider) {
-                    this._authThenStart().then(resolve, reject);
-                    return;
-                }
-                const error = new SseError(event.code, event.message, event);
-                reject(error);
-                this.onerror?.(error);
-            };
-            this._eventSource.onopen = () => {
-                // The connection is open, but we need to wait for the endpoint to be received.
-            };
-            this._eventSource.addEventListener('endpoint', (event) => {
-                const messageEvent = event;
-                try {
-                    this._endpoint = new URL(messageEvent.data, this._url);
-                    if (this._endpoint.origin !== this._url.origin) {
-                        throw new Error(`Endpoint origin does not match connection origin: ${this._endpoint.origin}`);
-                    }
-                }
-                catch (error) {
-                    reject(error);
-                    this.onerror?.(error);
-                    void this.close();
-                    return;
-                }
-                resolve();
-            });
-            this._eventSource.onmessage = (event) => {
-                const messageEvent = event;
-                let message;
-                try {
-                    message = types_js_1.JSONRPCMessageSchema.parse(JSON.parse(messageEvent.data));
-                }
-                catch (error) {
-                    this.onerror?.(error);
-                    return;
-                }
-                this.onmessage?.(message);
-            };
-        });
-    }
-    async start() {
-        if (this._eventSource) {
-            throw new Error('SSEClientTransport already started! If using Client class, note that connect() calls start() automatically.');
-        }
-        return await this._startOrAuth();
-    }
-    /**
-     * Call this method after the user has finished authorizing via their user agent and is redirected back to the MCP client application. This will exchange the authorization code for an access token, enabling the next connection attempt to successfully auth.
-     */
-    async finishAuth(authorizationCode) {
-        if (!this._authProvider) {
-            throw new auth_js_1.UnauthorizedError('No auth provider');
-        }
-        const result = await (0, auth_js_1.auth)(this._authProvider, {
-            serverUrl: this._url,
-            authorizationCode,
-            resourceMetadataUrl: this._resourceMetadataUrl,
-            scope: this._scope,
-            fetchFn: this._fetchWithInit
-        });
-        if (result !== 'AUTHORIZED') {
-            throw new auth_js_1.UnauthorizedError('Failed to authorize');
-        }
-    }
-    async close() {
-        this._abortController?.abort();
-        this._eventSource?.close();
-        this.onclose?.();
-    }
-    async send(message) {
-        if (!this._endpoint) {
-            throw new Error('Not connected');
-        }
-        try {
-            const headers = await this._commonHeaders();
-            headers.set('content-type', 'application/json');
-            const init = {
-                ...this._requestInit,
-                method: 'POST',
-                headers,
-                body: JSON.stringify(message),
-                signal: this._abortController?.signal
-            };
-            const response = await (this._fetch ?? fetch)(this._endpoint, init);
-            if (!response.ok) {
-                const text = await response.text().catch(() => null);
-                if (response.status === 401 && this._authProvider) {
-                    const { resourceMetadataUrl, scope } = (0, auth_js_1.extractWWWAuthenticateParams)(response);
-                    this._resourceMetadataUrl = resourceMetadataUrl;
-                    this._scope = scope;
-                    const result = await (0, auth_js_1.auth)(this._authProvider, {
-                        serverUrl: this._url,
-                        resourceMetadataUrl: this._resourceMetadataUrl,
-                        scope: this._scope,
-                        fetchFn: this._fetchWithInit
-                    });
-                    if (result !== 'AUTHORIZED') {
-                        throw new auth_js_1.UnauthorizedError();
-                    }
-                    // Purposely _not_ awaited, so we don't call onerror twice
-                    return this.send(message);
-                }
-                throw new Error(`Error POSTing to endpoint (HTTP ${response.status}): ${text}`);
-            }
-            // Release connection - POST responses don't have content we need
-            await response.body?.cancel();
-        }
-        catch (error) {
-            this.onerror?.(error);
-            throw error;
-        }
-    }
-    setProtocolVersion(version) {
-        this._protocolVersion = version;
-    }
-}
-exports.SSEClientTransport = SSEClientTransport;
-//# sourceMappingURL=sse.js.map

package/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/stdio.js

@@ -1,196 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StdioClientTransport = exports.DEFAULT_INHERITED_ENV_VARS = void 0;
-exports.getDefaultEnvironment = getDefaultEnvironment;
-const cross_spawn_1 = __importDefault(require("cross-spawn"));
-const node_process_1 = __importDefault(require("node:process"));
-const node_stream_1 = require("node:stream");
-const stdio_js_1 = require("../shared/stdio.js");
-/**
- * Environment variables to inherit by default, if an environment is not explicitly given.
- */
-exports.DEFAULT_INHERITED_ENV_VARS = node_process_1.default.platform === 'win32'
-    ? [
-        'APPDATA',
-        'HOMEDRIVE',
-        'HOMEPATH',
-        'LOCALAPPDATA',
-        'PATH',
-        'PROCESSOR_ARCHITECTURE',
-        'SYSTEMDRIVE',
-        'SYSTEMROOT',
-        'TEMP',
-        'USERNAME',
-        'USERPROFILE',
-        'PROGRAMFILES'
-    ]
-    : /* list inspired by the default env inheritance of sudo */
-        ['HOME', 'LOGNAME', 'PATH', 'SHELL', 'TERM', 'USER'];
-/**
- * Returns a default environment object including only environment variables deemed safe to inherit.
- */
-function getDefaultEnvironment() {
-    const env = {};
-    for (const key of exports.DEFAULT_INHERITED_ENV_VARS) {
-        const value = node_process_1.default.env[key];
-        if (value === undefined) {
-            continue;
-        }
-        if (value.startsWith('()')) {
-            // Skip functions, which are a security risk.
-            continue;
-        }
-        env[key] = value;
-    }
-    return env;
-}
-/**
- * Client transport for stdio: this will connect to a server by spawning a process and communicating with it over stdin/stdout.
- *
- * This transport is only available in Node.js environments.
- */
-class StdioClientTransport {
-    constructor(server) {
-        this._readBuffer = new stdio_js_1.ReadBuffer();
-        this._stderrStream = null;
-        this._serverParams = server;
-        if (server.stderr === 'pipe' || server.stderr === 'overlapped') {
-            this._stderrStream = new node_stream_1.PassThrough();
-        }
-    }
-    /**
-     * Starts the server process and prepares to communicate with it.
-     */
-    async start() {
-        if (this._process) {
-            throw new Error('StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.');
-        }
-        return new Promise((resolve, reject) => {
-            this._process = (0, cross_spawn_1.default)(this._serverParams.command, this._serverParams.args ?? [], {
-                // merge default env with server env because mcp server needs some env vars
-                env: {
-                    ...getDefaultEnvironment(),
-                    ...this._serverParams.env
-                },
-                stdio: ['pipe', 'pipe', this._serverParams.stderr ?? 'inherit'],
-                shell: false,
-                windowsHide: node_process_1.default.platform === 'win32',
-                cwd: this._serverParams.cwd
-            });
-            this._process.on('error', error => {
-                reject(error);
-                this.onerror?.(error);
-            });
-            this._process.on('spawn', () => {
-                resolve();
-            });
-            this._process.on('close', _code => {
-                this._process = undefined;
-                this.onclose?.();
-            });
-            this._process.stdin?.on('error', error => {
-                this.onerror?.(error);
-            });
-            this._process.stdout?.on('data', chunk => {
-                this._readBuffer.append(chunk);
-                this.processReadBuffer();
-            });
-            this._process.stdout?.on('error', error => {
-                this.onerror?.(error);
-            });
-            if (this._stderrStream && this._process.stderr) {
-                this._process.stderr.pipe(this._stderrStream);
-            }
-        });
-    }
-    /**
-     * The stderr stream of the child process, if `StdioServerParameters.stderr` was set to "pipe" or "overlapped".
-     *
-     * If stderr piping was requested, a PassThrough stream is returned _immediately_, allowing callers to
-     * attach listeners before the start method is invoked. This prevents loss of any early
-     * error output emitted by the child process.
-     */
-    get stderr() {
-        if (this._stderrStream) {
-            return this._stderrStream;
-        }
-        return this._process?.stderr ?? null;
-    }
-    /**
-     * The child process pid spawned by this transport.
-     *
-     * This is only available after the transport has been started.
-     */
-    get pid() {
-        return this._process?.pid ?? null;
-    }
-    processReadBuffer() {
-        while (true) {
-            try {
-                const message = this._readBuffer.readMessage();
-                if (message === null) {
-                    break;
-                }
-                this.onmessage?.(message);
-            }
-            catch (error) {
-                this.onerror?.(error);
-            }
-        }
-    }
-    async close() {
-        if (this._process) {
-            const processToClose = this._process;
-            this._process = undefined;
-            const closePromise = new Promise(resolve => {
-                processToClose.once('close', () => {
-                    resolve();
-                });
-            });
-            try {
-                processToClose.stdin?.end();
-            }
-            catch {
-                // ignore
-            }
-            await Promise.race([closePromise, new Promise(resolve => setTimeout(resolve, 2000).unref())]);
-            if (processToClose.exitCode === null) {
-                try {
-                    processToClose.kill('SIGTERM');
-                }
-                catch {
-                    // ignore
-                }
-                await Promise.race([closePromise, new Promise(resolve => setTimeout(resolve, 2000).unref())]);
-            }
-            if (processToClose.exitCode === null) {
-                try {
-                    processToClose.kill('SIGKILL');
-                }
-                catch {
-                    // ignore
-                }
-            }
-        }
-        this._readBuffer.clear();
-    }
-    send(message) {
-        return new Promise(resolve => {
-            if (!this._process?.stdin) {
-                throw new Error('Not connected');
-            }
-            const json = (0, stdio_js_1.serializeMessage)(message);
-            if (this._process.stdin.write(json)) {
-                resolve();
-            }
-            else {
-                this._process.stdin.once('drain', resolve);
-            }
-        });
-    }
-}
-exports.StdioClientTransport = StdioClientTransport;
-//# sourceMappingURL=stdio.js.map