@openclaw/twitch 2026.5.20 → 2026.5.22

package/node_modules/@twurple/api-call/lib/helpers/url.js

@@ -0,0 +1,25 @@
+import { getMockApiPort } from '@twurple/common';
+/** @internal */
+export function getTwitchApiUrl(url, type) {
+    const mockServerPort = getMockApiPort();
+    switch (type) {
+        case 'helix': {
+            const unprefixedUrl = url.replace(/^\//, '');
+            return mockServerPort
+                ? unprefixedUrl === 'eventsub/subscriptions'
+                    ? `http://localhost:${mockServerPort}/${unprefixedUrl}`
+                    : `http://localhost:${mockServerPort}/mock/${unprefixedUrl}`
+                : `https://api.twitch.tv/helix/${unprefixedUrl}`;
+        }
+        case 'auth': {
+            const unprefixedUrl = url.replace(/^\//, '');
+            return mockServerPort
+                ? `http://localhost:${mockServerPort}/auth/${unprefixedUrl}`
+                : `https://id.twitch.tv/oauth2/${unprefixedUrl}`;
+        }
+        case 'custom':
+            return url;
+        default:
+            return url; // wat
+    }
+}

package/node_modules/@twurple/api-call/lib/index.d.ts

@@ -0,0 +1,7 @@
+export { callTwitchApi, callTwitchApiRaw } from './apiCall.js';
+export type { HelixPaginatedResponse, HelixPaginatedResponseWithTotal, HelixResponse } from './HelixResponse.js';
+export type { TwitchApiCallFetchOptions, TwitchApiCallOptions, TwitchApiCallType } from './TwitchApiCallOptions.js';
+export { createBroadcasterQuery } from './helpers/queries.external.js';
+export { handleTwitchApiResponseError, transformTwitchApiResponse } from './helpers/transform.js';
+export { HttpStatusCodeError } from './errors/HttpStatusCodeError.js';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@twurple/api-call/lib/index.js

@@ -0,0 +1,4 @@
+export { callTwitchApi, callTwitchApiRaw } from './apiCall.js';
+export { createBroadcasterQuery } from './helpers/queries.external.js';
+export { handleTwitchApiResponseError, transformTwitchApiResponse } from './helpers/transform.js';
+export { HttpStatusCodeError } from './errors/HttpStatusCodeError.js';

package/node_modules/@twurple/api-call/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@twurple/api-call",
+  "version": "8.1.4",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "A light wrapper around the Twitch API.",
+  "keywords": [
+    "twitch",
+    "api",
+    "stream",
+    "bot"
+  ],
+  "sideEffects": false,
+  "type": "module",
+  "main": "lib",
+  "types": "lib",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/twurple/twurple.git",
+    "directory": "packages/api-call"
+  },
+  "homepage": "https://twurple.js.org",
+  "author": "Daniel Fischer <daniel@d-fischer.dev>",
+  "funding": "https://github.com/sponsors/d-fischer",
+  "license": "MIT",
+  "dependencies": {
+    "@d-fischer/shared-utils": "^3.6.1",
+    "@twurple/common": "8.1.4",
+    "tslib": "^2.0.3"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "lib",
+    "!lib/**/*.d.ts.map"
+  ]
+}

package/node_modules/@twurple/auth/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2023 Daniel Fischer
+
+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/@twurple/auth/README.md

@@ -0,0 +1,24 @@
+# Twurple - Authentication
+
+[![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/twurple/twurple/blob/main/LICENSE)
+[![npm version](https://img.shields.io/npm/v/@twurple/auth.svg?style=flat)](https://www.npmjs.com/package/@twurple/auth)
+![PRs welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)
+
+Authenticate with Twitch and stop caring about refreshing tokens.
+
+## Installation
+
+	npm install @twurple/auth
+	# or
+	yarn add @twurple/auth
+	# or
+	pnpm install @twurple/auth
+
+## Documentation
+
+A good place to start with this library is the [documentation](https://twurple.js.org)
+which also includes a complete reference of all classes and interfaces, as well as changes and deprecations between major versions.
+
+## If you're getting stuck...
+
+You can join the [Twitch API Libraries Discord Server](https://discord.gg/b9ZqMfz) and ask in `#twurple` for support.

package/node_modules/@twurple/auth/lib/AccessToken.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Represents the data of an OAuth access token returned by Twitch.
+ */
+export interface AccessToken {
+    /**
+     * The access token which is necessary for every request to the Twitch API.
+     */
+    accessToken: string;
+    /**
+     * The refresh token which is necessary to refresh the access token once it expires.
+     */
+    refreshToken: string | null;
+    /**
+     * The scope the access token is valid for, i.e. what the token enables you to do.
+     */
+    scope: string[];
+    /**
+     * The time, in seconds from the obtainment date, when the access token expires.
+     *
+     * May be `null`, in which case the token does not expire.
+     * This can only be the case with very old Client IDs.
+     *
+     * This does **not** honor the expiry grace period; it contains the exact value from Twitch.
+     */
+    expiresIn: number | null;
+    /**
+     * The date when the token was obtained, in epoch milliseconds.
+     */
+    obtainmentTimestamp: number;
+}
+/**
+ * Represents the data of an OAuth access token returned by Twitch, together with the ID of the user it represents.
+ *
+ * @inheritDoc
+ */
+export interface AccessTokenWithUserId extends AccessToken {
+    /**
+     * The ID of the user represented by the token.
+     */
+    userId: string;
+}
+/**
+ * Represents the data of an OAuth access token returned by Twitch, together with the ID of the user it represents,
+ * if it's not an app access token.
+ *
+ * @inheritDoc
+ */
+export interface AccessTokenMaybeWithUserId extends AccessToken {
+    /**
+     * The ID of the user represented by the token, or undefined if it's an app access token.
+     */
+    userId?: string;
+}
+/**
+ * The part of an access token that is required to calculate expiredness.
+ */
+export type ExpireableAccessToken = Pick<AccessToken, 'expiresIn' | 'obtainmentTimestamp'>;
+/**
+ * Calculates the date when the access token will expire.
+ *
+ * A one-minute grace period is applied for smooth handling of API latency.
+ *
+ * May be `null`, in which case the token does not expire.
+ * This can only be the case with very old Client IDs.
+ *
+ * @param token The access token.
+ */
+export declare function getExpiryDateOfAccessToken(token: ExpireableAccessToken): Date | null;
+/**
+ * Calculates whether the given access token is expired.
+ *
+ * A one-minute grace period is applied for smooth handling of API latency.
+ *
+ * @param token The access token.
+ */
+export declare function accessTokenIsExpired(token: ExpireableAccessToken): boolean;
+//# sourceMappingURL=AccessToken.d.ts.map

package/node_modules/@twurple/auth/lib/AccessToken.external.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AccessToken.external.d.ts.map

package/node_modules/@twurple/auth/lib/AccessToken.external.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@twurple/auth/lib/AccessToken.js

@@ -0,0 +1,29 @@
+import { mapNullable } from '@d-fischer/shared-utils';
+// one minute
+const EXPIRY_GRACE_PERIOD = 60000;
+function getExpiryMillis(token) {
+    return mapNullable(token.expiresIn, _ => token.obtainmentTimestamp + _ * 1000 - EXPIRY_GRACE_PERIOD);
+}
+/**
+ * Calculates the date when the access token will expire.
+ *
+ * A one-minute grace period is applied for smooth handling of API latency.
+ *
+ * May be `null`, in which case the token does not expire.
+ * This can only be the case with very old Client IDs.
+ *
+ * @param token The access token.
+ */
+export function getExpiryDateOfAccessToken(token) {
+    return mapNullable(getExpiryMillis(token), _ => new Date(_));
+}
+/**
+ * Calculates whether the given access token is expired.
+ *
+ * A one-minute grace period is applied for smooth handling of API latency.
+ *
+ * @param token The access token.
+ */
+export function accessTokenIsExpired(token) {
+    return mapNullable(getExpiryMillis(token), _ => Date.now() > _) ?? false;
+}

package/node_modules/@twurple/auth/lib/TokenFetcher.d.ts

@@ -0,0 +1,12 @@
+import type { AccessToken } from './AccessToken.js';
+export declare class TokenFetcher<T extends AccessToken = AccessToken> {
+    private readonly _executor;
+    private _newTokenScopeSets;
+    private _newTokenPromise;
+    private _queuedScopeSets;
+    private _queueExecutor;
+    private _queuePromise;
+    constructor(executor: (scopeSets: string[][]) => Promise<T>);
+    fetch(...scopeSets: Array<string[] | undefined>): Promise<T>;
+}
+//# sourceMappingURL=TokenFetcher.d.ts.map

package/node_modules/@twurple/auth/lib/TokenFetcher.js

@@ -0,0 +1,67 @@
+import { promiseWithResolvers } from '@d-fischer/shared-utils';
+export class TokenFetcher {
+    _executor;
+    _newTokenScopeSets = [];
+    _newTokenPromise = null;
+    _queuedScopeSets = [];
+    _queueExecutor = null;
+    _queuePromise = null;
+    constructor(executor) {
+        this._executor = executor;
+    }
+    async fetch(...scopeSets) {
+        const filteredScopeSets = scopeSets.filter((val) => Boolean(val));
+        if (this._newTokenPromise) {
+            if (!filteredScopeSets.length) {
+                return await this._newTokenPromise;
+            }
+            if (this._queueExecutor) {
+                this._queuedScopeSets.push(...filteredScopeSets);
+            }
+            else {
+                this._queuedScopeSets = [...filteredScopeSets];
+            }
+            if (!this._queuePromise) {
+                const { promise, resolve, reject } = promiseWithResolvers();
+                this._queuePromise = promise;
+                this._queueExecutor = async () => {
+                    if (!this._queuePromise) {
+                        return;
+                    }
+                    this._newTokenScopeSets = this._queuedScopeSets;
+                    this._queuedScopeSets = [];
+                    this._newTokenPromise = this._queuePromise;
+                    this._queuePromise = null;
+                    this._queueExecutor = null;
+                    try {
+                        resolve(await this._executor(this._newTokenScopeSets));
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                    finally {
+                        this._newTokenPromise = null;
+                        this._newTokenScopeSets = [];
+                        this._queueExecutor?.();
+                    }
+                };
+            }
+            return await this._queuePromise;
+        }
+        this._newTokenScopeSets = [...filteredScopeSets];
+        const { promise, resolve, reject } = promiseWithResolvers();
+        this._newTokenPromise = promise;
+        try {
+            resolve(await this._executor(this._newTokenScopeSets));
+        }
+        catch (e) {
+            reject(e);
+        }
+        finally {
+            this._newTokenPromise = null;
+            this._newTokenScopeSets = [];
+            this._queueExecutor?.();
+        }
+        return await promise;
+    }
+}

package/node_modules/@twurple/auth/lib/TokenInfo.d.ts

@@ -0,0 +1,31 @@
+import { DataObject } from '@twurple/common';
+import { type TokenInfoData } from './TokenInfo.external.js';
+/**
+ * Information about an access token.
+ */
+export declare class TokenInfo extends DataObject<TokenInfoData> {
+    private readonly _obtainmentDate;
+    /**
+     * The client ID.
+     */
+    get clientId(): string;
+    /**
+     * The ID of the authenticated user.
+     */
+    get userId(): string | null;
+    /**
+     * The name of the authenticated user.
+     */
+    get userName(): string | null;
+    /**
+     * The scopes for which the token is valid.
+     */
+    get scopes(): string[];
+    /**
+     * The time when the token will expire.
+     *
+     * If this returns null, it means that the token never expires (happens with some old client IDs).
+     */
+    get expiryDate(): Date | null;
+}
+//# sourceMappingURL=TokenInfo.d.ts.map

package/node_modules/@twurple/auth/lib/TokenInfo.external.d.ts

@@ -0,0 +1,8 @@
+export interface TokenInfoData {
+    client_id: string;
+    login?: string;
+    scopes: string[];
+    user_id?: string;
+    expires_in?: number;
+}
+//# sourceMappingURL=TokenInfo.external.d.ts.map

package/node_modules/@twurple/auth/lib/TokenInfo.external.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@twurple/auth/lib/TokenInfo.js

@@ -0,0 +1,50 @@
+import { __decorate } from "tslib";
+import { mapNullable } from '@d-fischer/shared-utils';
+import { DataObject, rawDataSymbol, rtfm } from '@twurple/common';
+/**
+ * Information about an access token.
+ */
+let TokenInfo = class TokenInfo extends DataObject {
+    _obtainmentDate;
+    /** @internal */
+    constructor(data) {
+        super(data);
+        this._obtainmentDate = new Date();
+    }
+    /**
+     * The client ID.
+     */
+    get clientId() {
+        return this[rawDataSymbol].client_id;
+    }
+    /**
+     * The ID of the authenticated user.
+     */
+    get userId() {
+        return this[rawDataSymbol].user_id ?? null;
+    }
+    /**
+     * The name of the authenticated user.
+     */
+    get userName() {
+        return this[rawDataSymbol].login ?? null;
+    }
+    /**
+     * The scopes for which the token is valid.
+     */
+    get scopes() {
+        return this[rawDataSymbol].scopes;
+    }
+    /**
+     * The time when the token will expire.
+     *
+     * If this returns null, it means that the token never expires (happens with some old client IDs).
+     */
+    get expiryDate() {
+        return mapNullable(this[rawDataSymbol].expires_in, v => new Date(this._obtainmentDate.getTime() + v * 1000));
+    }
+};
+TokenInfo = __decorate([
+    rtfm('auth', 'TokenInfo', 'clientId')
+], TokenInfo);
+export { TokenInfo };

package/node_modules/@twurple/auth/lib/errors/CachedRefreshFailureError.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown whenever you try to execute an action in the context of a user
+ * who is already known to have an invalid token saved in its {@link AuthProvider}.
+ */
+export declare class CachedRefreshFailureError extends CustomError {
+    readonly userId: string;
+    constructor(userId: string);
+}
+//# sourceMappingURL=CachedRefreshFailureError.d.ts.map

package/node_modules/@twurple/auth/lib/errors/CachedRefreshFailureError.js

@@ -0,0 +1,15 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown whenever you try to execute an action in the context of a user
+ * who is already known to have an invalid token saved in its {@link AuthProvider}.
+ */
+export class CachedRefreshFailureError extends CustomError {
+    userId;
+    constructor(userId) {
+        super(`The user context for the user ${userId} has been disabled.
+This happened because the access token became invalid (e.g. by expiry) and refreshing it failed (e.g. because the account's password was changed).
+
+Use .addUser(), .addUserForToken() or .addUserForCode() for the same user context to re-enable the user with a new, valid token.`);
+        this.userId = userId;
+    }
+}

package/node_modules/@twurple/auth/lib/errors/IntermediateUserRemovalError.d.ts

@@ -0,0 +1,10 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown whenever a user is removed from an {@link AuthProvider}
+ * and at the same time you try to execute an action in that user's context.
+ */
+export declare class IntermediateUserRemovalError extends CustomError {
+    readonly userId: string;
+    constructor(userId: string);
+}
+//# sourceMappingURL=IntermediateUserRemovalError.d.ts.map

package/node_modules/@twurple/auth/lib/errors/IntermediateUserRemovalError.js

@@ -0,0 +1,14 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown whenever a user is removed from an {@link AuthProvider}
+ * and at the same time you try to execute an action in that user's context.
+ */
+export class IntermediateUserRemovalError extends CustomError {
+    userId;
+    constructor(userId) {
+        super(`User ${userId} was removed while trying to fetch a token.
+
+Make sure you're not executing any actions when you want to remove a user.`);
+        this.userId = userId;
+    }
+}

package/node_modules/@twurple/auth/lib/errors/InvalidTokenError.d.ts

@@ -0,0 +1,9 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown whenever an invalid token is supplied.
+ */
+export declare class InvalidTokenError extends CustomError {
+    /** @private */
+    constructor(options?: ErrorOptions);
+}
+//# sourceMappingURL=InvalidTokenError.d.ts.map

package/node_modules/@twurple/auth/lib/errors/InvalidTokenError.js

@@ -0,0 +1,10 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown whenever an invalid token is supplied.
+ */
+export class InvalidTokenError extends CustomError {
+    /** @private */
+    constructor(options) {
+        super('Invalid token supplied', options);
+    }
+}

package/node_modules/@twurple/auth/lib/errors/InvalidTokenTypeError.d.ts

@@ -0,0 +1,7 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown whenever a different token type (user vs. app) is expected in the method you're calling.
+ */
+export declare class InvalidTokenTypeError extends CustomError {
+}
+//# sourceMappingURL=InvalidTokenTypeError.d.ts.map

package/node_modules/@twurple/auth/lib/errors/InvalidTokenTypeError.js

@@ -0,0 +1,6 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown whenever a different token type (user vs. app) is expected in the method you're calling.
+ */
+export class InvalidTokenTypeError extends CustomError {
+}

package/node_modules/@twurple/auth/lib/errors/UnknownIntentError.d.ts

@@ -0,0 +1,13 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown when an intent is requested that was not recognized by the {@link AuthProvider}.
+ */
+export declare class UnknownIntentError extends CustomError {
+    /**
+     * The intent that was requested.
+     */
+    readonly intent: string;
+    /** @private */
+    constructor(intent: string);
+}
+//# sourceMappingURL=UnknownIntentError.d.ts.map

package/node_modules/@twurple/auth/lib/errors/UnknownIntentError.js

@@ -0,0 +1,15 @@
+import { CustomError } from '@twurple/common';
+/**
+ * Thrown when an intent is requested that was not recognized by the {@link AuthProvider}.
+ */
+export class UnknownIntentError extends CustomError {
+    /**
+     * The intent that was requested.
+     */
+    intent;
+    /** @private */
+    constructor(intent) {
+        super(`Unknown intent: ${intent}`);
+        this.intent = intent;
+    }
+}

package/node_modules/@twurple/auth/lib/helpers.d.ts

@@ -0,0 +1,82 @@
+import type { Logger } from '@d-fischer/logger';
+import type { AccessToken } from './AccessToken.js';
+import type { AuthProvider } from './providers/AuthProvider.js';
+import { TokenInfo } from './TokenInfo.js';
+/**
+ * Gets an access token with your client credentials and an authorization code.
+ *
+ * @param clientId The client ID of your application.
+ * @param clientSecret The client secret of your application.
+ * @param code The authorization code.
+ * @param redirectUri The redirect URI.
+ *
+ * This serves no real purpose here, but must still match one of the redirect URIs you configured in the Twitch Developer dashboard.
+ */
+export declare function exchangeCode(clientId: string, clientSecret: string, code: string, redirectUri: string): Promise<AccessToken>;
+/**
+ * Gets an app access token with your client credentials.
+ *
+ * @param clientId The client ID of your application.
+ * @param clientSecret The client secret of your application.
+ */
+export declare function getAppToken(clientId: string, clientSecret: string): Promise<AccessToken>;
+/**
+ * Refreshes an expired access token with your client credentials and the refresh token that was given by the initial authentication.
+ *
+ * @param clientId The client ID of your application.
+ * @param clientSecret The client secret of your application.
+ * @param refreshToken The refresh token.
+ */
+export declare function refreshUserToken(clientId: string, clientSecret: string, refreshToken: string): Promise<AccessToken>;
+/**
+ * Revokes an access token.
+ *
+ * @param clientId The client ID of your application.
+ * @param accessToken The access token.
+ */
+export declare function revokeToken(clientId: string, accessToken: string): Promise<void>;
+/**
+ * Gets information about an access token.
+ *
+ * @param accessToken The access token to get the information of.
+ * @param clientId The client ID of your application.
+ *
+ * You need to obtain one using one of the [Twitch OAuth flows](https://dev.twitch.tv/docs/authentication/getting-tokens-oauth/).
+ */
+export declare function getTokenInfo(accessToken: string, clientId?: string): Promise<TokenInfo>;
+/** @private */
+export declare function getValidTokenFromProviderForUser(provider: AuthProvider, userId: string, scopes?: string[], logger?: Logger): Promise<{
+    accessToken: AccessToken;
+    tokenInfo: TokenInfo;
+}>;
+/** @private */
+export declare function getValidTokenFromProviderForIntent(provider: AuthProvider, intent: string, scopes?: string[], logger?: Logger): Promise<{
+    accessToken: AccessToken;
+    tokenInfo: TokenInfo;
+}>;
+/**
+ * Compares scopes for a non-upgradable {@link AuthProvider} instance.
+ *
+ * @param scopesToCompare The scopes to compare against.
+ * @param requestedScopes The scopes you requested.
+ */
+export declare function compareScopes(scopesToCompare: string[], requestedScopes?: string[]): void;
+/**
+ * Compares scope sets for a non-upgradable {@link AuthProvider} instance.
+ *
+ * @param scopesToCompare The scopes to compare against.
+ * @param requestedScopeSets The scope sets you requested.
+ */
+export declare function compareScopeSets(scopesToCompare: string[], requestedScopeSets: string[][]): void;
+/**
+ * Compares scopes for a non-upgradable `AuthProvider` instance, loading them from the token if necessary,
+ * and returns them together with the user ID.
+ *
+ * @param clientId The client ID of your application.
+ * @param token The access token.
+ * @param userId The user ID that was already loaded.
+ * @param loadedScopes The scopes that were already loaded.
+ * @param requestedScopeSets The scope sets you requested.
+ */
+export declare function loadAndCompareTokenInfo(clientId: string, token: string, userId?: string, loadedScopes?: string[], requestedScopeSets?: Array<string[] | undefined>): Promise<[string[] | undefined, string]>;
+//# sourceMappingURL=helpers.d.ts.map

package/node_modules/@twurple/auth/lib/helpers.external.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=helpers.external.d.ts.map