@openclaw/slack 2026.9.3 → 2026.9.5

package/node_modules/@slack/socket-mode/node_modules/@types/retry/index.d.ts

@@ -1,151 +0,0 @@
-// Type definitions for retry 0.12
-// Project: https://github.com/tim-kos/node-retry
-// Definitions by: Stan Goldmann <https://github.com/krenor>
-//                 BendingBender <https://github.com/BendingBender>
-// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
-
-export interface RetryOperation {
-    /**
-     * Returns an array of all errors that have been passed to `retryOperation.retry()` so far.
-     * The returning array has the errors ordered chronologically based on when they were passed to
-     * `retryOperation.retry()`, which means the first passed error is at index zero and the last is at the last index.
-     */
-    errors(): Error[];
-
-    /**
-     * A reference to the error object that occured most frequently.
-     * Errors are compared using the `error.message` property.
-     * If multiple error messages occured the same amount of time, the last error object with that message is returned.
-     *
-     * @return If no errors occured so far the value will be `null`.
-     */
-    mainError(): Error | null;
-
-    /**
-     * Defines the function that is to be retried and executes it for the first time right away.
-     *
-     * @param fn The function that is to be retried. `currentAttempt` represents the number of attempts
-     * callback has been executed so far.
-     * @param [timeoutOps.timeout] A timeout in milliseconds.
-     * @param [timeoutOps.callback] Callback to execute when the operation takes longer than the timeout.
-     */
-    attempt(fn: (currentAttempt: number) => void, timeoutOps?: AttemptTimeoutOptions): void;
-
-    /**
-     * Returns `false` when no `error` value is given, or the maximum amount of retries has been reached.
-     * Otherwise it returns `true`, and retries the operation after the timeout for the current attempt number.
-     */
-    retry(err?: Error): boolean;
-
-    /**
-     * Stops the operation being retried. Useful for aborting the operation on a fatal error etc.
-     */
-    stop(): void;
-
-    /**
-     * Resets the internal state of the operation object, so that you can call `attempt()` again as if
-     * this was a new operation object.
-     */
-    reset(): void;
-
-    /**
-     * Returns an int representing the number of attempts it took to call `fn` before it was successful.
-     */
-    attempts(): number;
-}
-
-export interface AttemptTimeoutOptions {
-    /**
-     * A timeout in milliseconds.
-     */
-    timeout?: number;
-    /**
-     * Callback to execute when the operation takes longer than the timeout.
-     */
-    callback?(): void;
-}
-
-/**
- * Create a new RetryOperation object.
- *
- * @param [options.retries=10] The maximum amount of times to retry the operation.
- * @param [options.factor=2] The exponential factor to use.
- * @param [options.minTimeout=1000] The number of milliseconds before starting the first retry.
- * @param [options.maxTimeout=Infinity] The maximum number of milliseconds between two retries.
- * @param [options.randomize=false] Randomizes the timeouts by multiplying a factor between 1-2.
- * @param [options.forever=false] Wether to retry forever.
- * @param [options.unref=false] Wether to unref the setTimeout's.
- *
- */
-export function operation(options?: OperationOptions): RetryOperation;
-
-export interface OperationOptions extends TimeoutsOptions {
-    /**
-     * Whether to retry forever.
-     * @default false
-     */
-    forever?: boolean;
-    /**
-     * Whether to [unref](https://nodejs.org/api/timers.html#timers_unref) the setTimeout's.
-     * @default false
-     */
-    unref?: boolean;
-    /**
-     * The maximum time (in milliseconds) that the retried operation is allowed to run.
-     * @default Infinity
-     */
-    maxRetryTime?: number;
-}
-
-/** Get an array with timeouts and their return values in milliseconds. */
-export function timeouts(options?: TimeoutsOptions): number[];
-
-export interface TimeoutsOptions extends CreateTimeoutOptions {
-    /**
-     * The maximum amount of times to retry the operation.
-     * @default 10
-     */
-    retries?: number;
-}
-
-/**
- * Create a new timeout (in milliseconds) based on the given parameters.
- *
- * @param attempt  Representing for which retry the timeout should be calculated.
- * @return timeout
- */
-export function createTimeout(attempt: number, options?: CreateTimeoutOptions): number;
-
-export interface CreateTimeoutOptions {
-    /**
-     * The exponential factor to use.
-     * @default 2
-     */
-    factor?: number;
-    /**
-     * The number of milliseconds before starting the first retry.
-     * @default 1000
-     */
-    minTimeout?: number;
-    /**
-     * The maximum number of milliseconds between two retries.
-     * @default Infinity
-     */
-    maxTimeout?: number;
-    /**
-     * Randomizes the timeouts by multiplying a factor between 1-2.
-     * @default false
-     */
-    randomize?: boolean;
-}
-
-/**
- * Wrap all functions of the object with retry.
- *
- * @param object The object to be wrapped
- * @param methods Methods which need to be wrapped
- *
- */
-export function wrap(object: object, methods?: string[]): void;
-export function wrap(object: object, options?: OperationOptions, methods?: string[]): void;

package/node_modules/@slack/socket-mode/node_modules/@types/retry/package.json

@@ -1,28 +0,0 @@
-{
-    "name": "@types/retry",
-    "version": "0.12.0",
-    "description": "TypeScript definitions for retry",
-    "license": "MIT",
-    "contributors": [
-        {
-            "name": "Stan Goldmann",
-            "url": "https://github.com/krenor",
-            "githubUsername": "krenor"
-        },
-        {
-            "name": "BendingBender",
-            "url": "https://github.com/BendingBender",
-            "githubUsername": "BendingBender"
-        }
-    ],
-    "main": "",
-    "types": "index",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git"
-    },
-    "scripts": {},
-    "dependencies": {},
-    "typesPublisherContentHash": "dc8156aa3c27632d2585c45d8951c4a0f7ae9122bd17190d8973018556d174f3",
-    "typeScriptVersion": "2.3"
-}

package/node_modules/@slack/socket-mode/node_modules/p-finally/index.js

@@ -1,15 +0,0 @@
-'use strict';
-module.exports = (promise, onFinally) => {
-	onFinally = onFinally || (() => {});
-
-	return promise.then(
-		val => new Promise(resolve => {
-			resolve(onFinally());
-		}).then(() => val),
-		err => new Promise(resolve => {
-			resolve(onFinally());
-		}).then(() => {
-			throw err;
-		})
-	);
-};

package/node_modules/@slack/socket-mode/node_modules/p-finally/license

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

package/node_modules/@slack/socket-mode/node_modules/p-finally/package.json

@@ -1,42 +0,0 @@
-{
-  "name": "p-finally",
-  "version": "1.0.0",
-  "description": "`Promise#finally()` ponyfill - Invoked when the promise is settled regardless of outcome",
-  "license": "MIT",
-  "repository": "sindresorhus/p-finally",
-  "author": {
-    "name": "Sindre Sorhus",
-    "email": "sindresorhus@gmail.com",
-    "url": "sindresorhus.com"
-  },
-  "engines": {
-    "node": ">=4"
-  },
-  "scripts": {
-    "test": "xo && ava"
-  },
-  "files": [
-    "index.js"
-  ],
-  "keywords": [
-    "promise",
-    "finally",
-    "handler",
-    "function",
-    "async",
-    "await",
-    "promises",
-    "settled",
-    "ponyfill",
-    "polyfill",
-    "shim",
-    "bluebird"
-  ],
-  "devDependencies": {
-    "ava": "*",
-    "xo": "*"
-  },
-  "xo": {
-    "esnext": true
-  }
-}

package/node_modules/@slack/socket-mode/node_modules/p-finally/readme.md

@@ -1,47 +0,0 @@
-# p-finally [![Build Status](https://travis-ci.org/sindresorhus/p-finally.svg?branch=master)](https://travis-ci.org/sindresorhus/p-finally)
-
-> [`Promise#finally()`](https://github.com/tc39/proposal-promise-finally) [ponyfill](https://ponyfill.com) - Invoked when the promise is settled regardless of outcome
-
-Useful for cleanup.
-
-
-## Install
-
-```
-$ npm install --save p-finally
-```
-
-
-## Usage
-
-```js
-const pFinally = require('p-finally');
-
-const dir = createTempDir();
-
-pFinally(write(dir), () => cleanup(dir));
-```
-
-
-## API
-
-### pFinally(promise, [onFinally])
-
-Returns a `Promise`.
-
-#### onFinally
-
-Type: `Function`
-
-Note: Throwing or returning a rejected promise will reject `promise` with the rejection reason.
-
-
-## Related
-
-- [p-try](https://github.com/sindresorhus/p-try) - `Promise#try()` ponyfill - Starts a promise chain
-- [More…](https://github.com/sindresorhus/promise-fun)
-
-
-## License
-
-MIT © [Sindre Sorhus](https://sindresorhus.com)

package/node_modules/@slack/socket-mode/node_modules/p-queue/dist/index.d.ts

@@ -1,101 +0,0 @@
-import EventEmitter = require('eventemitter3');
-import { Queue, RunFunction } from './queue';
-import PriorityQueue from './priority-queue';
-import { QueueAddOptions, DefaultAddOptions, Options } from './options';
-declare type Task<TaskResultType> = (() => PromiseLike<TaskResultType>) | (() => TaskResultType);
-/**
-Promise queue with concurrency control.
-*/
-export default class PQueue<QueueType extends Queue<RunFunction, EnqueueOptionsType> = PriorityQueue, EnqueueOptionsType extends QueueAddOptions = DefaultAddOptions> extends EventEmitter<'active' | 'idle' | 'add' | 'next'> {
-    private readonly _carryoverConcurrencyCount;
-    private readonly _isIntervalIgnored;
-    private _intervalCount;
-    private readonly _intervalCap;
-    private readonly _interval;
-    private _intervalEnd;
-    private _intervalId?;
-    private _timeoutId?;
-    private _queue;
-    private readonly _queueClass;
-    private _pendingCount;
-    private _concurrency;
-    private _isPaused;
-    private _resolveEmpty;
-    private _resolveIdle;
-    private _timeout?;
-    private readonly _throwOnTimeout;
-    constructor(options?: Options<QueueType, EnqueueOptionsType>);
-    private get _doesIntervalAllowAnother();
-    private get _doesConcurrentAllowAnother();
-    private _next;
-    private _resolvePromises;
-    private _onResumeInterval;
-    private _isIntervalPaused;
-    private _tryToStartAnother;
-    private _initializeIntervalIfNeeded;
-    private _onInterval;
-    /**
-    Executes all queued functions until it reaches the limit.
-    */
-    private _processQueue;
-    get concurrency(): number;
-    set concurrency(newConcurrency: number);
-    /**
-    Adds a sync or async task to the queue. Always returns a promise.
-    */
-    add<TaskResultType>(fn: Task<TaskResultType>, options?: Partial<EnqueueOptionsType>): Promise<TaskResultType>;
-    /**
-    Same as `.add()`, but accepts an array of sync or async functions.
-
-    @returns A promise that resolves when all functions are resolved.
-    */
-    addAll<TaskResultsType>(functions: ReadonlyArray<Task<TaskResultsType>>, options?: EnqueueOptionsType): Promise<TaskResultsType[]>;
-    /**
-    Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
-    */
-    start(): this;
-    /**
-    Put queue execution on hold.
-    */
-    pause(): void;
-    /**
-    Clear the queue.
-    */
-    clear(): void;
-    /**
-    Can be called multiple times. Useful if you for example add additional items at a later time.
-
-    @returns A promise that settles when the queue becomes empty.
-    */
-    onEmpty(): Promise<void>;
-    /**
-    The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
-
-    @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
-    */
-    onIdle(): Promise<void>;
-    /**
-    Size of the queue.
-    */
-    get size(): number;
-    /**
-    Size of the queue, filtered by the given options.
-
-    For example, this can be used to find the number of items remaining in the queue with a specific priority level.
-    */
-    sizeBy(options: Readonly<Partial<EnqueueOptionsType>>): number;
-    /**
-    Number of pending promises.
-    */
-    get pending(): number;
-    /**
-    Whether the queue is currently paused.
-    */
-    get isPaused(): boolean;
-    get timeout(): number | undefined;
-    /**
-    Set the timeout for future operations.
-    */
-    set timeout(milliseconds: number | undefined);
-}
-export { Queue, QueueAddOptions, DefaultAddOptions, Options };

package/node_modules/@slack/socket-mode/node_modules/p-queue/dist/index.js

@@ -1,279 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const EventEmitter = require("eventemitter3");
-const p_timeout_1 = require("p-timeout");
-const priority_queue_1 = require("./priority-queue");
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-const empty = () => { };
-const timeoutError = new p_timeout_1.TimeoutError();
-/**
-Promise queue with concurrency control.
-*/
-class PQueue extends EventEmitter {
-    constructor(options) {
-        var _a, _b, _c, _d;
-        super();
-        this._intervalCount = 0;
-        this._intervalEnd = 0;
-        this._pendingCount = 0;
-        this._resolveEmpty = empty;
-        this._resolveIdle = empty;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        options = Object.assign({ carryoverConcurrencyCount: false, intervalCap: Infinity, interval: 0, concurrency: Infinity, autoStart: true, queueClass: priority_queue_1.default }, options);
-        if (!(typeof options.intervalCap === 'number' && options.intervalCap >= 1)) {
-            throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${(_b = (_a = options.intervalCap) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ''}\` (${typeof options.intervalCap})`);
-        }
-        if (options.interval === undefined || !(Number.isFinite(options.interval) && options.interval >= 0)) {
-            throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${(_d = (_c = options.interval) === null || _c === void 0 ? void 0 : _c.toString()) !== null && _d !== void 0 ? _d : ''}\` (${typeof options.interval})`);
-        }
-        this._carryoverConcurrencyCount = options.carryoverConcurrencyCount;
-        this._isIntervalIgnored = options.intervalCap === Infinity || options.interval === 0;
-        this._intervalCap = options.intervalCap;
-        this._interval = options.interval;
-        this._queue = new options.queueClass();
-        this._queueClass = options.queueClass;
-        this.concurrency = options.concurrency;
-        this._timeout = options.timeout;
-        this._throwOnTimeout = options.throwOnTimeout === true;
-        this._isPaused = options.autoStart === false;
-    }
-    get _doesIntervalAllowAnother() {
-        return this._isIntervalIgnored || this._intervalCount < this._intervalCap;
-    }
-    get _doesConcurrentAllowAnother() {
-        return this._pendingCount < this._concurrency;
-    }
-    _next() {
-        this._pendingCount--;
-        this._tryToStartAnother();
-        this.emit('next');
-    }
-    _resolvePromises() {
-        this._resolveEmpty();
-        this._resolveEmpty = empty;
-        if (this._pendingCount === 0) {
-            this._resolveIdle();
-            this._resolveIdle = empty;
-            this.emit('idle');
-        }
-    }
-    _onResumeInterval() {
-        this._onInterval();
-        this._initializeIntervalIfNeeded();
-        this._timeoutId = undefined;
-    }
-    _isIntervalPaused() {
-        const now = Date.now();
-        if (this._intervalId === undefined) {
-            const delay = this._intervalEnd - now;
-            if (delay < 0) {
-                // Act as the interval was done
-                // We don't need to resume it here because it will be resumed on line 160
-                this._intervalCount = (this._carryoverConcurrencyCount) ? this._pendingCount : 0;
-            }
-            else {
-                // Act as the interval is pending
-                if (this._timeoutId === undefined) {
-                    this._timeoutId = setTimeout(() => {
-                        this._onResumeInterval();
-                    }, delay);
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-    _tryToStartAnother() {
-        if (this._queue.size === 0) {
-            // We can clear the interval ("pause")
-            // Because we can redo it later ("resume")
-            if (this._intervalId) {
-                clearInterval(this._intervalId);
-            }
-            this._intervalId = undefined;
-            this._resolvePromises();
-            return false;
-        }
-        if (!this._isPaused) {
-            const canInitializeInterval = !this._isIntervalPaused();
-            if (this._doesIntervalAllowAnother && this._doesConcurrentAllowAnother) {
-                const job = this._queue.dequeue();
-                if (!job) {
-                    return false;
-                }
-                this.emit('active');
-                job();
-                if (canInitializeInterval) {
-                    this._initializeIntervalIfNeeded();
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-    _initializeIntervalIfNeeded() {
-        if (this._isIntervalIgnored || this._intervalId !== undefined) {
-            return;
-        }
-        this._intervalId = setInterval(() => {
-            this._onInterval();
-        }, this._interval);
-        this._intervalEnd = Date.now() + this._interval;
-    }
-    _onInterval() {
-        if (this._intervalCount === 0 && this._pendingCount === 0 && this._intervalId) {
-            clearInterval(this._intervalId);
-            this._intervalId = undefined;
-        }
-        this._intervalCount = this._carryoverConcurrencyCount ? this._pendingCount : 0;
-        this._processQueue();
-    }
-    /**
-    Executes all queued functions until it reaches the limit.
-    */
-    _processQueue() {
-        // eslint-disable-next-line no-empty
-        while (this._tryToStartAnother()) { }
-    }
-    get concurrency() {
-        return this._concurrency;
-    }
-    set concurrency(newConcurrency) {
-        if (!(typeof newConcurrency === 'number' && newConcurrency >= 1)) {
-            throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
-        }
-        this._concurrency = newConcurrency;
-        this._processQueue();
-    }
-    /**
-    Adds a sync or async task to the queue. Always returns a promise.
-    */
-    async add(fn, options = {}) {
-        return new Promise((resolve, reject) => {
-            const run = async () => {
-                this._pendingCount++;
-                this._intervalCount++;
-                try {
-                    const operation = (this._timeout === undefined && options.timeout === undefined) ? fn() : p_timeout_1.default(Promise.resolve(fn()), (options.timeout === undefined ? this._timeout : options.timeout), () => {
-                        if (options.throwOnTimeout === undefined ? this._throwOnTimeout : options.throwOnTimeout) {
-                            reject(timeoutError);
-                        }
-                        return undefined;
-                    });
-                    resolve(await operation);
-                }
-                catch (error) {
-                    reject(error);
-                }
-                this._next();
-            };
-            this._queue.enqueue(run, options);
-            this._tryToStartAnother();
-            this.emit('add');
-        });
-    }
-    /**
-    Same as `.add()`, but accepts an array of sync or async functions.
-
-    @returns A promise that resolves when all functions are resolved.
-    */
-    async addAll(functions, options) {
-        return Promise.all(functions.map(async (function_) => this.add(function_, options)));
-    }
-    /**
-    Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
-    */
-    start() {
-        if (!this._isPaused) {
-            return this;
-        }
-        this._isPaused = false;
-        this._processQueue();
-        return this;
-    }
-    /**
-    Put queue execution on hold.
-    */
-    pause() {
-        this._isPaused = true;
-    }
-    /**
-    Clear the queue.
-    */
-    clear() {
-        this._queue = new this._queueClass();
-    }
-    /**
-    Can be called multiple times. Useful if you for example add additional items at a later time.
-
-    @returns A promise that settles when the queue becomes empty.
-    */
-    async onEmpty() {
-        // Instantly resolve if the queue is empty
-        if (this._queue.size === 0) {
-            return;
-        }
-        return new Promise(resolve => {
-            const existingResolve = this._resolveEmpty;
-            this._resolveEmpty = () => {
-                existingResolve();
-                resolve();
-            };
-        });
-    }
-    /**
-    The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
-
-    @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
-    */
-    async onIdle() {
-        // Instantly resolve if none pending and if nothing else is queued
-        if (this._pendingCount === 0 && this._queue.size === 0) {
-            return;
-        }
-        return new Promise(resolve => {
-            const existingResolve = this._resolveIdle;
-            this._resolveIdle = () => {
-                existingResolve();
-                resolve();
-            };
-        });
-    }
-    /**
-    Size of the queue.
-    */
-    get size() {
-        return this._queue.size;
-    }
-    /**
-    Size of the queue, filtered by the given options.
-
-    For example, this can be used to find the number of items remaining in the queue with a specific priority level.
-    */
-    sizeBy(options) {
-        // eslint-disable-next-line unicorn/no-fn-reference-in-iterator
-        return this._queue.filter(options).length;
-    }
-    /**
-    Number of pending promises.
-    */
-    get pending() {
-        return this._pendingCount;
-    }
-    /**
-    Whether the queue is currently paused.
-    */
-    get isPaused() {
-        return this._isPaused;
-    }
-    get timeout() {
-        return this._timeout;
-    }
-    /**
-    Set the timeout for future operations.
-    */
-    set timeout(milliseconds) {
-        this._timeout = milliseconds;
-    }
-}
-exports.default = PQueue;

package/node_modules/@slack/socket-mode/node_modules/p-queue/dist/lower-bound.d.ts

@@ -1 +0,0 @@
-export default function lowerBound<T>(array: readonly T[], value: T, comparator: (a: T, b: T) => number): number;