@lagent_titi/kick.js-ts 1.0.1

package/dist/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@lagent_titi/kick.js-ts",
+  "version": "1.0.1",
+  "description": "Node.js TypeScript client for Kick.com API",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lagentiti/kick.api-ts.git"
+  },
+  "keywords": [
+    "kick",
+    "kickapi",
+    "kickcom",
+    "api"
+  ],
+  "author": "botk4cp3r",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/BOT-K4CP3R/kick.api/issues"
+  },
+  "homepage": "https://github.com/BOT-K4CP3R/kick.api#readme",
+  "dependencies": {
+    "express": "^4.21.2"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.3",
+    "@types/node": "^24.0.10",
+    "cpx": "^1.5.0",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsc && cpx \"package.json\" dist && cpx \"README.md\" dist",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/dist/services/categories.d.ts

@@ -0,0 +1,7 @@
+export declare class CategoriesService {
+    private apiClient;
+    private baseUrl;
+    constructor(apiClient: any);
+    getCategories(searchQuery?: string, token?: string): Promise<any>;
+    getCategory(categoryId: string | number, token?: string): Promise<any>;
+}

package/dist/services/categories.js

@@ -0,0 +1,30 @@
+export class CategoriesService {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.baseUrl = 'https://api.kick.com/public/v1/categories';
+    }
+    async getCategories(searchQuery = '', token = '') {
+        const url = new URL(this.baseUrl);
+        if (searchQuery) {
+            url.searchParams.append('q', searchQuery);
+        }
+        const response = await fetch(url.toString(), {
+            method: 'GET',
+            headers: Object.assign({}, (token && { Authorization: `Bearer ${token}` }))
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return await response.json();
+    }
+    async getCategory(categoryId, token = '') {
+        const response = await fetch(`${this.baseUrl}/${categoryId}`, {
+            method: 'GET',
+            headers: Object.assign({}, (token && { Authorization: `Bearer ${token}` }))
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return await response.json();
+    }
+}

package/dist/services/channels.d.ts

@@ -0,0 +1,10 @@
+export declare class ChannelsService {
+    private apiClient;
+    private baseUrl;
+    constructor(apiClient: any);
+    getChannels(broadcasterIds: (string | number)[] | undefined, token: string): Promise<any>;
+    updateChannel(options: {
+        categoryId: number | string;
+        streamTitle: string;
+    }, token: string): Promise<boolean>;
+}

package/dist/services/channels.js

@@ -0,0 +1,46 @@
+import { UnauthorizedError, ForbiddenError } from '../errors';
+export class ChannelsService {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.baseUrl = 'https://api.kick.com/public/v1/channels';
+    }
+    async getChannels(broadcasterIds = [], token) {
+        const url = new URL(this.baseUrl);
+        if (broadcasterIds.length > 0) {
+            broadcasterIds.forEach(id => url.searchParams.append('broadcaster_user_id[]', id.toString()));
+        }
+        const response = await fetch(url.toString(), {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        });
+        if (response.status === 401)
+            throw new UnauthorizedError();
+        if (response.status === 403)
+            throw new ForbiddenError();
+        if (!response.ok)
+            throw new Error(`HTTP error! status: ${response.status}`);
+        return await response.json();
+    }
+    async updateChannel(options, token) {
+        const response = await fetch(this.baseUrl, {
+            method: 'PATCH',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                category_id: options.categoryId,
+                stream_title: options.streamTitle
+            })
+        });
+        if (response.status === 401)
+            throw new UnauthorizedError();
+        if (response.status === 403)
+            throw new ForbiddenError();
+        if (!response.ok)
+            throw new Error(`HTTP error! status: ${response.status}`);
+        return response.status === 204;
+    }
+}

package/dist/services/chat.d.ts

@@ -0,0 +1,13 @@
+interface SendMessageOptions {
+    content: string;
+    type?: 'user' | 'bot';
+    broadcasterUserId?: number | string;
+    token: string;
+}
+export declare class ChatService {
+    private apiClient;
+    private baseUrl;
+    constructor(apiClient: any);
+    sendMessage(options: SendMessageOptions): Promise<any>;
+}
+export {};

package/dist/services/chat.js

@@ -0,0 +1,43 @@
+import { UnauthorizedError, ForbiddenError } from '../errors';
+export class ChatService {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.baseUrl = 'https://api.kick.com/public/v1/chat';
+    }
+    async sendMessage(options) {
+        const payload = {
+            content: options.content,
+            type: options.type || 'bot'
+        };
+        if (payload.type === 'user') {
+            if (!options.broadcasterUserId) {
+                throw new Error('broadcaster_user_id is required for user type messages');
+            }
+            payload.broadcaster_user_id = options.broadcasterUserId;
+        }
+        if (payload.content.length > 500) {
+            throw new Error('Message content cannot exceed 500 characters');
+        }
+        if (!['user', 'bot'].includes(payload.type)) {
+            throw new Error('Message type must be either "user" or "bot"');
+        }
+        const response = await fetch(this.baseUrl, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${options.token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(payload)
+        });
+        if (response.status === 401)
+            throw new UnauthorizedError();
+        if (response.status === 403)
+            throw new ForbiddenError();
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            throw new Error(`HTTP error! status: ${response.status}, message: ${error.message || 'Unknown error'}`);
+        }
+        const result = await response.json();
+        return result.data || result;
+    }
+}

package/dist/services/events.d.ts

@@ -0,0 +1,40 @@
+import { WebhookType } from '../types/webhooks';
+export type { WebhookType };
+export interface WebhookHeaders {
+    'kick-event-message-id': string;
+    'kick-event-message-timestamp': string;
+    'kick-event-signature': string;
+    'kick-event-type': WebhookType;
+    'kick-event-version': string;
+    [key: string]: string;
+}
+interface ApiClient {
+    getPublicKey: () => Promise<{
+        data: {
+            public_key: string;
+        };
+    }>;
+    options: {
+        webhookBaseUrl: string;
+        webhookPort: number;
+        webhookPath: string;
+    };
+}
+export declare class EventsService {
+    private apiClient;
+    private verifier;
+    private baseUrl;
+    constructor(apiClient: ApiClient);
+    initializeVerifier(): Promise<void>;
+    validateWebhook(headers: WebhookHeaders, body: string): {
+        isValid: boolean;
+        eventType: WebhookType;
+        version: string;
+        messageId: string;
+        timestamp: string;
+        payload: unknown;
+    };
+    getSubscriptions(token: string): Promise<unknown>;
+    subscribe(events: WebhookType[], method: "webhook" | string | undefined, token: string): Promise<unknown>;
+    unsubscribe(subscriptionIds: string[], token: string): Promise<boolean>;
+}

package/dist/services/events.js

@@ -0,0 +1,100 @@
+import { SignatureVerifier } from '../utils/signature';
+import { UnauthorizedError, ForbiddenError } from '../errors';
+import { parseWebhookPayload } from '../types/webhooks';
+export class EventsService {
+    constructor(apiClient) {
+        this.verifier = null;
+        this.baseUrl = 'https://api.kick.com/public/v1/events';
+        this.apiClient = apiClient;
+    }
+    async initializeVerifier() {
+        if (!this.verifier) {
+            const publicKeyResponse = await this.apiClient.getPublicKey();
+            this.verifier = new SignatureVerifier(publicKeyResponse.data.public_key);
+        }
+    }
+    validateWebhook(headers, body) {
+        if (!this.verifier) {
+            throw new Error('Signature verifier not initialized');
+        }
+        const messageId = headers['kick-event-message-id'];
+        const timestamp = headers['kick-event-message-timestamp'];
+        const signature = headers['kick-event-signature'];
+        const eventType = headers['kick-event-type'];
+        const version = headers['kick-event-version'];
+        if (!messageId || !timestamp || !signature) {
+            throw new Error('Missing required webhook headers');
+        }
+        const isValid = this.verifier.verify(messageId, timestamp, body, signature);
+        const parsedPayload = parseWebhookPayload(eventType, JSON.parse(body));
+        return {
+            isValid,
+            eventType,
+            version,
+            messageId,
+            timestamp,
+            payload: parsedPayload
+        };
+    }
+    async getSubscriptions(token) {
+        const response = await fetch(`${this.baseUrl}/subscriptions`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        });
+        if (response.status === 401)
+            throw new UnauthorizedError();
+        if (response.status === 403)
+            throw new ForbiddenError();
+        if (!response.ok)
+            throw new Error(`HTTP error! status: ${response.status}`);
+        return await response.json();
+    }
+    async subscribe(events, method = 'webhook', token) {
+        const webhookUrl = `${this.apiClient.options.webhookBaseUrl}:${this.apiClient.options.webhookPort}${this.apiClient.options.webhookPath}`;
+        const payload = {
+            method: method,
+            url: webhookUrl,
+            types: events.map((eventName) => ({
+                name: eventName,
+                version: 1
+            }))
+        };
+        const response = await fetch(`${this.baseUrl}/subscriptions`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(payload)
+        });
+        if (response.status === 401)
+            throw new UnauthorizedError();
+        if (response.status === 403)
+            throw new ForbiddenError();
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            throw new Error(`HTTP error! status: ${response.status}, message: ${JSON.stringify(error)}`);
+        }
+        return await response.json();
+    }
+    async unsubscribe(subscriptionIds, token) {
+        const url = new URL(`${this.baseUrl}/subscriptions`);
+        subscriptionIds.forEach(id => url.searchParams.append('id[]', id));
+        const response = await fetch(url.toString(), {
+            method: 'DELETE',
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        });
+        if (response.status === 401)
+            throw new UnauthorizedError();
+        if (response.status === 403)
+            throw new ForbiddenError();
+        if (!response.ok && response.status !== 204) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return response.status === 204;
+    }
+}

package/dist/services/publicKey.d.ts

@@ -0,0 +1,6 @@
+export declare class PublicKeyService {
+    private apiClient;
+    private baseUrl;
+    constructor(apiClient: any);
+    getPublicKey(): Promise<any>;
+}

package/dist/services/publicKey.js

@@ -0,0 +1,17 @@
+import { UnauthorizedError } from '../errors';
+export class PublicKeyService {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.baseUrl = 'https://api.kick.com/public/v1/public-key';
+    }
+    async getPublicKey() {
+        const response = await fetch(this.baseUrl, {
+            method: 'GET'
+        });
+        if (response.status === 401)
+            throw new UnauthorizedError();
+        if (!response.ok)
+            throw new Error(`HTTP error! status: ${response.status}`);
+        return await response.json();
+    }
+}

package/dist/services/users.d.ts

@@ -0,0 +1,7 @@
+export declare class UsersService {
+    private apiClient;
+    private baseUrl;
+    constructor(apiClient: any);
+    introspectToken(token: string): Promise<any>;
+    getUsers(userIds: string[] | undefined, token: string): Promise<any>;
+}

package/dist/services/users.js

@@ -0,0 +1,39 @@
+import { UnauthorizedError, ForbiddenError } from '../errors';
+export class UsersService {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+        this.baseUrl = 'https://api.kick.com/public/v1';
+    }
+    async introspectToken(token) {
+        const response = await fetch(`${this.baseUrl}/token/introspect`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        });
+        if (response.status === 401)
+            throw new UnauthorizedError();
+        if (!response.ok)
+            throw new Error(`HTTP error! status: ${response.status}`);
+        return await response.json();
+    }
+    async getUsers(userIds = [], token) {
+        const url = new URL(`${this.baseUrl}/users`);
+        if (userIds.length > 0) {
+            userIds.forEach(id => url.searchParams.append('id[]', id));
+        }
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${token}`
+            }
+        });
+        if (response.status === 401)
+            throw new UnauthorizedError();
+        if (response.status === 403)
+            throw new ForbiddenError();
+        if (!response.ok)
+            throw new Error(`HTTP error! status: ${response.status}`);
+        return await response.json();
+    }
+}

package/dist/types/webhooks.d.ts

@@ -0,0 +1,9 @@
+export declare const WEBHOOK_TYPES: {
+    readonly CHAT_MESSAGE: "chat.message.sent";
+    readonly CHANNEL_FOLLOWED: "channel.followed";
+    readonly SUBSCRIPTION_RENEWAL: "channel.subscription.renewal";
+    readonly SUBSCRIPTION_GIFTS: "channel.subscription.gifts";
+    readonly SUBSCRIPTION_NEW: "channel.subscription.new";
+};
+export type WebhookType = (typeof WEBHOOK_TYPES)[keyof typeof WEBHOOK_TYPES];
+export declare function parseWebhookPayload(type: WebhookType, payload: any): any;

package/dist/types/webhooks.js

@@ -0,0 +1,111 @@
+export const WEBHOOK_TYPES = {
+    CHAT_MESSAGE: 'chat.message.sent',
+    CHANNEL_FOLLOWED: 'channel.followed',
+    SUBSCRIPTION_RENEWAL: 'channel.subscription.renewal',
+    SUBSCRIPTION_GIFTS: 'channel.subscription.gifts',
+    SUBSCRIPTION_NEW: 'channel.subscription.new'
+};
+export function parseWebhookPayload(type, payload) {
+    switch (type) {
+        case WEBHOOK_TYPES.CHAT_MESSAGE:
+            return {
+                messageId: payload.message_id,
+                broadcaster: {
+                    isAnonymous: payload.broadcaster.is_anonymous,
+                    userId: payload.broadcaster.user_id,
+                    username: payload.broadcaster.username,
+                    isVerified: payload.broadcaster.is_verified,
+                    profilePicture: payload.broadcaster.profile_picture,
+                    channelSlug: payload.broadcaster.channel_slug
+                },
+                sender: {
+                    isAnonymous: payload.sender.is_anonymous,
+                    userId: payload.sender.user_id,
+                    username: payload.sender.username,
+                    isVerified: payload.sender.is_verified,
+                    profilePicture: payload.sender.profile_picture,
+                    channelSlug: payload.sender.channel_slug
+                },
+                content: payload.content,
+                emotes: Array.isArray(payload.emotes)
+                    ? payload.emotes.map((emote) => ({
+                        emoteId: emote.emote_id,
+                        positions: emote.positions
+                    }))
+                    : null
+            };
+        case WEBHOOK_TYPES.CHANNEL_FOLLOWED:
+            return {
+                broadcaster: {
+                    isAnonymous: payload.broadcaster.is_anonymous,
+                    userId: payload.broadcaster.user_id,
+                    username: payload.broadcaster.username,
+                    isVerified: payload.broadcaster.is_verified,
+                    profilePicture: payload.broadcaster.profile_picture,
+                    channelSlug: payload.broadcaster.channel_slug
+                },
+                follower: {
+                    isAnonymous: payload.follower.is_anonymous,
+                    userId: payload.follower.user_id,
+                    username: payload.follower.username,
+                    isVerified: payload.follower.is_verified,
+                    profilePicture: payload.follower.profile_picture,
+                    channelSlug: payload.follower.channel_slug
+                }
+            };
+        case WEBHOOK_TYPES.SUBSCRIPTION_RENEWAL:
+        case WEBHOOK_TYPES.SUBSCRIPTION_NEW:
+            return {
+                broadcaster: {
+                    isAnonymous: payload.broadcaster.is_anonymous,
+                    userId: payload.broadcaster.user_id,
+                    username: payload.broadcaster.username,
+                    isVerified: payload.broadcaster.is_verified,
+                    profilePicture: payload.broadcaster.profile_picture,
+                    channelSlug: payload.broadcaster.channel_slug
+                },
+                subscriber: {
+                    isAnonymous: payload.subscriber.is_anonymous,
+                    userId: payload.subscriber.user_id,
+                    username: payload.subscriber.username,
+                    isVerified: payload.subscriber.is_verified,
+                    profilePicture: payload.subscriber.profile_picture,
+                    channelSlug: payload.subscriber.channel_slug
+                },
+                duration: payload.duration,
+                createdAt: new Date(payload.created_at)
+            };
+        case WEBHOOK_TYPES.SUBSCRIPTION_GIFTS:
+            return {
+                broadcaster: {
+                    isAnonymous: payload.broadcaster.is_anonymous,
+                    userId: payload.broadcaster.user_id,
+                    username: payload.broadcaster.username,
+                    isVerified: payload.broadcaster.is_verified,
+                    profilePicture: payload.broadcaster.profile_picture,
+                    channelSlug: payload.broadcaster.channel_slug
+                },
+                gifter: payload.gifter.is_anonymous
+                    ? { isAnonymous: true }
+                    : {
+                        isAnonymous: false,
+                        userId: payload.gifter.user_id,
+                        username: payload.gifter.username,
+                        isVerified: payload.gifter.is_verified,
+                        profilePicture: payload.gifter.profile_picture,
+                        channelSlug: payload.gifter.channel_slug
+                    },
+                giftees: payload.giftees.map((giftee) => ({
+                    isAnonymous: giftee.is_anonymous,
+                    userId: giftee.user_id,
+                    username: giftee.username,
+                    isVerified: giftee.is_verified,
+                    profilePicture: giftee.profile_picture,
+                    channelSlug: giftee.channel_slug
+                })),
+                createdAt: new Date(payload.created_at)
+            };
+        default:
+            return payload;
+    }
+}

package/dist/utils/signature.d.ts

@@ -0,0 +1,6 @@
+export declare class SignatureVerifier {
+    private publicKey;
+    constructor(publicKey: string | Buffer);
+    createSignaturePayload(messageId: string, timestamp: string, body: string): string;
+    verify(messageId: string, timestamp: string, body: string, signature: string): boolean;
+}

package/dist/utils/signature.js

@@ -0,0 +1,21 @@
+import crypto from 'crypto';
+export class SignatureVerifier {
+    constructor(publicKey) {
+        this.publicKey = publicKey;
+    }
+    createSignaturePayload(messageId, timestamp, body) {
+        return `${messageId}.${timestamp}.${body}`;
+    }
+    verify(messageId, timestamp, body, signature) {
+        const payload = this.createSignaturePayload(messageId, timestamp, body);
+        const verifier = crypto.createVerify('RSA-SHA256');
+        verifier.update(payload);
+        try {
+            const signatureBuffer = Buffer.from(signature, 'base64');
+            return verifier.verify(this.publicKey, signatureBuffer);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}

package/dist/webhooks/handler.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from 'events';
+export declare class WebhookHandler {
+    private client;
+    constructor(client: EventEmitter);
+    handleWebhook(headers: Record<string, string>, rawBody: Buffer | string | object): Promise<{
+        eventType: string;
+        eventVersion: string;
+        payload: any;
+    }>;
+}

package/dist/webhooks/handler.js

@@ -0,0 +1,59 @@
+export class WebhookHandler {
+    constructor(client) {
+        this.client = client;
+    }
+    async handleWebhook(headers, rawBody) {
+        const body = rawBody instanceof Buffer ? rawBody.toString('utf8') : rawBody;
+        const payload = typeof body === 'string' ? JSON.parse(body) : body;
+        const eventType = headers['kick-event-type'];
+        const eventVersion = headers['kick-event-version'];
+        switch (eventType) {
+            case 'chat.message.sent':
+                this.client.emit('chatMessage', {
+                    messageId: payload.message_id,
+                    broadcaster: payload.broadcaster,
+                    sender: payload.sender,
+                    content: payload.content,
+                    emotes: payload.emotes || []
+                });
+                break;
+            case 'channel.followed':
+                this.client.emit('channelFollowed', {
+                    broadcaster: payload.broadcaster,
+                    follower: payload.follower
+                });
+                break;
+            case 'channel.subscription.renewal':
+                this.client.emit('subscriptionRenewal', {
+                    broadcaster: payload.broadcaster,
+                    subscriber: payload.subscriber,
+                    duration: payload.duration,
+                    createdAt: payload.created_at
+                });
+                break;
+            case 'channel.subscription.gifts':
+                this.client.emit('subscriptionGifts', {
+                    broadcaster: payload.broadcaster,
+                    gifter: payload.gifter,
+                    giftees: payload.giftees,
+                    createdAt: payload.created_at
+                });
+                break;
+            case 'channel.subscription.new':
+                this.client.emit('subscriptionNew', {
+                    broadcaster: payload.broadcaster,
+                    subscriber: payload.subscriber,
+                    duration: payload.duration,
+                    createdAt: payload.created_at
+                });
+                break;
+            default:
+                this.client.emit('unknownEvent', { eventType, payload });
+        }
+        return {
+            eventType,
+            eventVersion,
+            payload
+        };
+    }
+}

package/dist/webhooks/server.d.ts

@@ -0,0 +1,17 @@
+import { EventEmitter } from 'events';
+interface WebhookServerOptions {
+    port?: number;
+    path?: string;
+}
+export declare class WebhookServer {
+    private client;
+    private port;
+    private path;
+    private app;
+    private server;
+    constructor(client: EventEmitter, options?: WebhookServerOptions);
+    private setup;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+export {};