@nekosuneprojects/nekosunevrtools 1.1.0 → 1.1.1

package/src/games/provider/nekosune-api.js

@@ -0,0 +1,329 @@
+function createGamesProvider(baseUrl) {
+  const root = String(baseUrl || "https://api.nekosunevr.co.uk").replace(/\/+$/, "");
+
+  async function getClashOfClansClan(context) {
+    const { http, apiKey, clanTag } = context;
+    assertApiKey(apiKey);
+    const tag = normalizeTag(clanTag, "clanTag");
+
+    const response = await http.get(`${root}/v5/games/api/clashofclans/clans/${encodeURIComponent(tag)}`, {
+      headers: buildHeaders(apiKey)
+    });
+    return response.data || {};
+  }
+
+  async function getClashOfClansPlayer(context) {
+    const { http, apiKey, playerTag } = context;
+    assertApiKey(apiKey);
+    const tag = normalizeTag(playerTag, "playerTag");
+
+    const response = await http.get(`${root}/v5/games/api/clashofclans/players/${encodeURIComponent(tag)}`, {
+      headers: buildHeaders(apiKey)
+    });
+    return response.data || {};
+  }
+
+  async function getDivision2Player(context) {
+    const { http, apiKey, username, platform } = context;
+    assertApiKey(apiKey);
+
+    const normalizedUsername = String(username || "").trim();
+    if (!normalizedUsername) {
+      throw new Error("Missing username.");
+    }
+    const normalizedPlatform = String(platform || "psn").trim().toLowerCase();
+    if (!normalizedPlatform) {
+      throw new Error("Missing platform.");
+    }
+
+    const payload = new URLSearchParams();
+    payload.set("username", normalizedUsername);
+    payload.set("platform", normalizedPlatform);
+
+    const response = await http.post(`${root}/v5/games/api/division2/player`, payload.toString(), {
+      headers: {
+        ...buildHeaders(apiKey),
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    return response.data || {};
+  }
+
+  async function getFortnitePlayer(context) {
+    const { http, apiKey, username, timeWindow } = context;
+    assertApiKey(apiKey);
+
+    const normalizedUsername = String(username || "").trim();
+    if (!normalizedUsername) {
+      throw new Error("Missing username.");
+    }
+    const normalizedTimeWindow = String(timeWindow || "lifetime").trim().toLowerCase();
+    if (!normalizedTimeWindow) {
+      throw new Error("Missing timeWindow.");
+    }
+
+    const payload = new URLSearchParams();
+    payload.set("username", normalizedUsername);
+    payload.set("timeWindow", normalizedTimeWindow);
+
+    const response = await http.post(`${root}/v5/games/api/fortnite/player`, payload.toString(), {
+      headers: {
+        ...buildHeaders(apiKey),
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    return response.data || {};
+  }
+
+  async function getFortniteCreatorCode(context) {
+    const { http, apiKey, creatorCode } = context;
+    assertApiKey(apiKey);
+
+    const normalizedCreatorCode = String(creatorCode || "").trim();
+    if (!normalizedCreatorCode) {
+      throw new Error("Missing creatorCode.");
+    }
+
+    const response = await http.get(`${root}/v5/games/api/fortnite/creatorcode/${encodeURIComponent(normalizedCreatorCode)}`, {
+      headers: buildHeaders(apiKey)
+    });
+    return response.data || {};
+  }
+
+  async function getFortniteItemShop(context) {
+    const { http, apiKey } = context;
+    assertApiKey(apiKey);
+
+    const response = await http.get(`${root}/v5/games/api/fortnite/item-shop`, {
+      headers: buildHeaders(apiKey)
+    });
+    return response.data || {};
+  }
+
+  async function getWynncraftProfile(context) {
+    const { http, apiKey, username } = context;
+    assertApiKey(apiKey);
+
+    const normalizedUsername = String(username || "").trim();
+    if (!normalizedUsername) {
+      throw new Error("Missing username.");
+    }
+
+    const response = await http.get(`${root}/v5/games/api/wynncraft/profile/${encodeURIComponent(normalizedUsername)}`, {
+      headers: buildHeaders(apiKey)
+    });
+    return response.data || {};
+  }
+
+  async function getHypixelProfile(context) {
+    const { http, apiKey, username } = context;
+    assertApiKey(apiKey);
+
+    const normalizedUsername = String(username || "").trim();
+    if (!normalizedUsername) {
+      throw new Error("Missing username.");
+    }
+
+    const response = await http.get(`${root}/v5/games/api/hypixel/profile/${encodeURIComponent(normalizedUsername)}`, {
+      headers: buildHeaders(apiKey)
+    });
+    return response.data || {};
+  }
+
+  async function getRocketLeaguePlayer(context) {
+    const { http, apiKey, username, platform } = context;
+    assertApiKey(apiKey);
+
+    const normalizedUsername = String(username || "").trim();
+    if (!normalizedUsername) {
+      throw new Error("Missing username.");
+    }
+    const normalizedPlatform = String(platform || "psn").trim().toLowerCase();
+    if (!normalizedPlatform) {
+      throw new Error("Missing platform.");
+    }
+
+    const payload = new URLSearchParams();
+    payload.set("username", normalizedUsername);
+    payload.set("platform", normalizedPlatform);
+
+    const response = await http.post(`${root}/v5/games/api/rocketleague/player`, payload.toString(), {
+      headers: {
+        ...buildHeaders(apiKey),
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    return response.data || {};
+  }
+
+  async function getApexLegendsPlayer(context) {
+    const { http, apiKey, username, platform } = context;
+    assertApiKey(apiKey);
+
+    const normalizedUsername = String(username || "").trim();
+    if (!normalizedUsername) {
+      throw new Error("Missing username.");
+    }
+    const normalizedPlatform = String(platform || "psn").trim().toLowerCase();
+    if (!normalizedPlatform) {
+      throw new Error("Missing platform.");
+    }
+
+    const payload = new URLSearchParams();
+    payload.set("username", normalizedUsername);
+    payload.set("platform", normalizedPlatform);
+
+    const response = await http.post(`${root}/v5/games/api/apexlegends/player`, payload.toString(), {
+      headers: {
+        ...buildHeaders(apiKey),
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    return response.data || {};
+  }
+
+  async function getBattlefield1Player(context) {
+    const { http, apiKey, username, platform } = context;
+    assertApiKey(apiKey);
+
+    const normalizedUsername = String(username || "").trim();
+    if (!normalizedUsername) {
+      throw new Error("Missing username.");
+    }
+    const normalizedPlatform = String(platform || "psn").trim().toLowerCase();
+    if (!normalizedPlatform) {
+      throw new Error("Missing platform.");
+    }
+
+    const payload = new URLSearchParams();
+    payload.set("username", normalizedUsername);
+    payload.set("platform", normalizedPlatform);
+
+    const response = await http.post(`${root}/v5/games/api/battlefield1/player`, payload.toString(), {
+      headers: {
+        ...buildHeaders(apiKey),
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    return response.data || {};
+  }
+
+  async function getBattlefield5Player(context) {
+    const { http, apiKey, username, platform } = context;
+    assertApiKey(apiKey);
+
+    const normalizedUsername = String(username || "").trim();
+    if (!normalizedUsername) {
+      throw new Error("Missing username.");
+    }
+    const normalizedPlatform = String(platform || "psn").trim().toLowerCase();
+    if (!normalizedPlatform) {
+      throw new Error("Missing platform.");
+    }
+
+    const payload = new URLSearchParams();
+    payload.set("username", normalizedUsername);
+    payload.set("platform", normalizedPlatform);
+
+    const response = await http.post(`${root}/v5/games/api/battlefield5/player`, payload.toString(), {
+      headers: {
+        ...buildHeaders(apiKey),
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    return response.data || {};
+  }
+
+  async function getBattlefield2042Player(context) {
+    const { http, apiKey, username, platform } = context;
+    assertApiKey(apiKey);
+
+    const normalizedUsername = String(username || "").trim();
+    if (!normalizedUsername) {
+      throw new Error("Missing username.");
+    }
+    const normalizedPlatform = String(platform || "ea").trim().toLowerCase();
+    if (!normalizedPlatform) {
+      throw new Error("Missing platform.");
+    }
+
+    const payload = new URLSearchParams();
+    payload.set("username", normalizedUsername);
+    payload.set("platform", normalizedPlatform);
+
+    const response = await http.post(`${root}/v5/games/api/battlefield2042/player`, payload.toString(), {
+      headers: {
+        ...buildHeaders(apiKey),
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    return response.data || {};
+  }
+
+  async function getBattlefield6Player(context) {
+    const { http, apiKey, username, platform } = context;
+    assertApiKey(apiKey);
+
+    const normalizedUsername = String(username || "").trim();
+    if (!normalizedUsername) {
+      throw new Error("Missing username.");
+    }
+    const normalizedPlatform = String(platform || "psn").trim().toLowerCase();
+    if (!normalizedPlatform) {
+      throw new Error("Missing platform.");
+    }
+
+    const payload = new URLSearchParams();
+    payload.set("username", normalizedUsername);
+    payload.set("platform", normalizedPlatform);
+
+    const response = await http.post(`${root}/v5/games/api/battlefield6/player`, payload.toString(), {
+      headers: {
+        ...buildHeaders(apiKey),
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    return response.data || {};
+  }
+
+  return {
+    getClashOfClansClan,
+    getClashOfClansPlayer,
+    getDivision2Player,
+    getFortnitePlayer,
+    getFortniteCreatorCode,
+    getFortniteItemShop,
+    getWynncraftProfile,
+    getHypixelProfile,
+    getRocketLeaguePlayer,
+    getApexLegendsPlayer,
+    getBattlefield1Player,
+    getBattlefield5Player,
+    getBattlefield2042Player,
+    getBattlefield6Player
+  };
+}
+
+function normalizeTag(tag, fieldName) {
+  if (!tag) {
+    throw new Error(`Missing ${fieldName}.`);
+  }
+  return String(tag).replace(/^#/, "").trim().toUpperCase();
+}
+
+function assertApiKey(apiKey) {
+  if (!apiKey) {
+    throw new Error("Missing API key. Pass apiKey in client options or method options.");
+  }
+}
+
+function buildHeaders(apiKey) {
+  return {
+    "nekosunevr-api-key": apiKey,
+    Authorization: `Bearer ${apiKey}`
+  };
+}
+
+module.exports = {
+  createGamesProvider
+};

package/src/games/providers.js

@@ -0,0 +1,14 @@
+const { createGamesProvider } = require("./provider/nekosune-api");
+
+const presets = {
+  nekosune: "https://api.nekosunevr.co.uk"
+};
+
+const providers = {
+  nekosune: createGamesProvider
+};
+
+module.exports = {
+  presets,
+  providers
+};

package/src/index.d.ts

@@ -88,6 +88,54 @@ export interface DoodstreamProvider extends VideoProviderAdapter {
   remoteUploadActions(context: unknown): Promise<{ provider: "doodstream"; success: boolean; raw: unknown }>;
 }
 
+export interface DownloadJobState {
+  job_id: string;
+  status: string;
+  url?: string | null;
+  download?: { percent?: number; label?: string };
+  convert?: { percent?: number; label?: string };
+  upload?: { percent?: number; label?: string };
+  [key: string]: unknown;
+}
+
+export interface DownloaderCreateJobResult {
+  provider: string;
+  jobId: string;
+  raw: unknown;
+}
+
+export interface DownloaderClientOptions {
+  apiKey?: string;
+  baseUrl?: string;
+  preset?: string;
+  timeoutMs?: number;
+}
+
+export interface DownloaderJobOptions {
+  apiKey?: string;
+  uploadDest?: "cdn" | "thirdparty" | "ipfs" | string;
+  timeoutMs?: number;
+}
+
+export interface DownloaderWaitOptions extends DownloaderJobOptions {
+  intervalMs?: number;
+  onProgress?: (state: DownloadJobState) => void;
+}
+
+export declare class DownloaderClient {
+  constructor(options?: DownloaderClientOptions);
+  useBaseUrl(baseUrl: string): this;
+  usePreset(name: string): this;
+  createMp3Job(link: string, options?: DownloaderJobOptions): Promise<DownloaderCreateJobResult>;
+  createMp4Job(link: string, options?: DownloaderJobOptions): Promise<DownloaderCreateJobResult>;
+  getJob(jobId: string, options?: DownloaderJobOptions): Promise<DownloadJobState>;
+  waitForJob(jobId: string, options?: DownloaderWaitOptions): Promise<DownloadJobState>;
+  getInfo(url: string, options?: { flat?: boolean; flatPlaylist?: boolean; fields?: "basic" | "full"; cache?: 0 | 1 | number; timeoutMs?: number }): Promise<unknown>;
+  searchYouTube(query: string, options?: { limit?: number; timeoutMs?: number }): Promise<unknown>;
+  getStreamUrl(url: string): string;
+  stream(url: string, options?: { responseType?: string; timeoutMs?: number }): Promise<unknown>;
+}
+
 export interface UploadAndShortenResult {
   success: true;
   upload: UploadResult;
@@ -150,6 +198,74 @@ export declare const platforms: {
 };
 
 export declare const shortenerPresets: Record<string, string>;
+export declare const downloaderPresets: Record<string, string>;
+
+export interface LivestreamClientOptions {
+  apiKey?: string;
+  baseUrl?: string;
+  preset?: string;
+  timeoutMs?: number;
+}
+
+export interface LivestreamResult {
+  statusCode?: number;
+  status?: string;
+  username?: string;
+  displayname?: string;
+  avatar?: string;
+  livestream?: {
+    online?: boolean;
+    bg?: string | null;
+    title?: string | null;
+    viewer?: number | null;
+    game?: string | null;
+    preview?: string | null;
+    created_at?: string | null;
+  };
+  followers?: number;
+  [key: string]: unknown;
+}
+
+export declare class LivestreamClient {
+  constructor(options?: LivestreamClientOptions);
+  useBaseUrl(baseUrl: string): this;
+  usePreset(name: string): this;
+  getKick(username: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<LivestreamResult>;
+  getTwitch(username: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<LivestreamResult>;
+  getDlive(username: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<LivestreamResult>;
+  getTrovo(username: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<LivestreamResult>;
+  getByPlatform(platform: string, username: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<LivestreamResult>;
+}
+
+export interface GamesClientOptions {
+  apiKey?: string;
+  baseUrl?: string;
+  preset?: string;
+  timeoutMs?: number;
+}
+
+export declare class GamesClient {
+  constructor(options?: GamesClientOptions);
+  useBaseUrl(baseUrl: string): this;
+  usePreset(name: string): this;
+  getClashOfClansClan(clanTag: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+  getClashOfClansPlayer(playerTag: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+  getDivision2Player(username: string, platform?: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+  getFortnitePlayer(username: string, timeWindow?: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+  getFortniteCreatorCode(creatorCode: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+  getFortniteItemShop(options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+  getWynncraftProfile(username: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+  getHypixelProfile(username: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+  getRocketLeaguePlayer(username: string, platform?: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+  getApexLegendsPlayer(username: string, platform?: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+  getBattlefield1Player(username: string, platform?: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+  getBattlefield5Player(username: string, platform?: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+  getBattlefield2042Player(username: string, platform?: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+  getBattlefield6Player(username: string, platform?: string, options?: { apiKey?: string; timeoutMs?: number }): Promise<unknown>;
+}
+
+export declare const livestreamPresets: Record<string, string>;
+export declare const gamesPresets: Record<string, string>;
 
 export declare const upload: {
   Client: typeof UploadClient;
@@ -169,6 +285,30 @@ export declare const video: {
   };
 };
 
+export declare const downloader: {
+  Client: typeof DownloaderClient;
+  providers: {
+    compatible: unknown;
+  };
+  presets: typeof downloaderPresets;
+};
+
+export declare const livestream: {
+  Client: typeof LivestreamClient;
+  providers: {
+    nekosune: unknown;
+  };
+  presets: typeof livestreamPresets;
+};
+
+export declare const games: {
+  Client: typeof GamesClient;
+  providers: {
+    nekosune: unknown;
+  };
+  presets: typeof gamesPresets;
+};
+
 export declare const earnings: {
   Client: typeof EarningsClient;
 };

package/src/index.js

@@ -2,6 +2,9 @@ const { UploadClient, providers: uploadProviders } = require("./upload/client");
 const { EarningsClient, shortenerPresets } = require("./earnings");
 const { providers: shorturlProviders } = require("./shorturl/providers");
 const videoProviders = require("./video/providers");
+const { DownloaderClient, presets: downloaderPresets, providers: downloaderProviders } = require("./downloader/client");
+const { LivestreamClient, presets: livestreamPresets, providers: livestreamProviders } = require("./livestream/client");
+const { GamesClient, presets: gamesPresets, providers: gamesProviders } = require("./games/client");
 
 module.exports = {
   upload: {
@@ -15,11 +18,32 @@ module.exports = {
   video: {
     providers: videoProviders
   },
+  downloader: {
+    Client: DownloaderClient,
+    providers: downloaderProviders,
+    presets: downloaderPresets
+  },
+  livestream: {
+    Client: LivestreamClient,
+    providers: livestreamProviders,
+    presets: livestreamPresets
+  },
+  games: {
+    Client: GamesClient,
+    providers: gamesProviders,
+    presets: gamesPresets
+  },
   earnings: {
     Client: EarningsClient
   },
   UploadClient,
   platforms: uploadProviders,
   EarningsClient,
-  shortenerPresets
-};
+  shortenerPresets,
+  DownloaderClient,
+  downloaderPresets,
+  LivestreamClient,
+  livestreamPresets,
+  GamesClient,
+  gamesPresets
+};

package/src/livestream/client.js

@@ -0,0 +1,70 @@
+const axios = require("axios");
+const { presets, providers } = require("./providers");
+
+class LivestreamClient {
+  constructor(options = {}) {
+    this.timeoutMs = options.timeoutMs || 60000;
+    this.apiKey = options.apiKey || null;
+    this.baseUrl = resolveBaseUrl(options.baseUrl, options.preset || "nekosune");
+    this.provider = providers.nekosune(this.baseUrl);
+  }
+
+  useBaseUrl(baseUrl) {
+    this.baseUrl = resolveBaseUrl(baseUrl);
+    this.provider = providers.nekosune(this.baseUrl);
+    return this;
+  }
+
+  usePreset(name) {
+    this.baseUrl = resolveBaseUrl(null, name);
+    this.provider = providers.nekosune(this.baseUrl);
+    return this;
+  }
+
+  getKick(username, options = {}) {
+    return this.provider.getKick(this.buildContext(username, options));
+  }
+
+  getTwitch(username, options = {}) {
+    return this.provider.getTwitch(this.buildContext(username, options));
+  }
+
+  getDlive(username, options = {}) {
+    return this.provider.getDlive(this.buildContext(username, options));
+  }
+
+  getTrovo(username, options = {}) {
+    return this.provider.getTrovo(this.buildContext(username, options));
+  }
+
+  getByPlatform(platform, username, options = {}) {
+    return this.provider.getByPlatform({
+      ...this.buildContext(username, options),
+      platform
+    }, platform);
+  }
+
+  buildContext(username, options) {
+    return {
+      http: axios.create({ timeout: options.timeoutMs || this.timeoutMs }),
+      apiKey: options.apiKey || this.apiKey,
+      username
+    };
+  }
+}
+
+function resolveBaseUrl(baseUrl, preset) {
+  if (baseUrl) {
+    return String(baseUrl).replace(/\/+$/, "");
+  }
+  if (preset && presets[preset]) {
+    return presets[preset];
+  }
+  throw new Error(`Unknown livestream preset "${preset}". Available: ${Object.keys(presets).join(", ")}`);
+}
+
+module.exports = {
+  LivestreamClient,
+  presets,
+  providers
+};

package/src/livestream/provider/nekosune-api.js

@@ -0,0 +1,56 @@
+function createLivestreamProvider(baseUrl) {
+  const root = String(baseUrl || "https://api.nekosunevr.co.uk").replace(/\/+$/, "");
+
+  async function getKick(context) {
+    return getByPlatform(context, "kick");
+  }
+
+  async function getTwitch(context) {
+    return getByPlatform(context, "twitch");
+  }
+
+  async function getDlive(context) {
+    return getByPlatform(context, "dlive");
+  }
+
+  async function getTrovo(context) {
+    return getByPlatform(context, "trovo");
+  }
+
+  async function getByPlatform(context, platform) {
+    const { http, apiKey, username } = context;
+    assertApiKey(apiKey);
+    if (!username) {
+      throw new Error(`Missing username for livestream platform "${platform}".`);
+    }
+    const response = await http.get(`${root}/v5/social/api/${platform}/${encodeURIComponent(username)}`, {
+      headers: buildHeaders(apiKey)
+    });
+    return response.data || {};
+  }
+
+  return {
+    getKick,
+    getTwitch,
+    getDlive,
+    getTrovo,
+    getByPlatform
+  };
+}
+
+function assertApiKey(apiKey) {
+  if (!apiKey) {
+    throw new Error("Missing API key. Pass apiKey in client options or method options.");
+  }
+}
+
+function buildHeaders(apiKey) {
+  return {
+    "nekosunevr-api-key": apiKey,
+    Authorization: `Bearer ${apiKey}`
+  };
+}
+
+module.exports = {
+  createLivestreamProvider
+};

package/src/livestream/providers.js

@@ -0,0 +1,14 @@
+const { createLivestreamProvider } = require("./provider/nekosune-api");
+
+const presets = {
+  nekosune: "https://api.nekosunevr.co.uk"
+};
+
+const providers = {
+  nekosune: createLivestreamProvider
+};
+
+module.exports = {
+  presets,
+  providers
+};