@nekosuneprojects/nekosunevrtools 1.1.0

package/src/index.d.ts

@@ -0,0 +1,174 @@
+export interface UploadResult {
+  platform: string;
+  success: boolean;
+  url: string;
+  raw: unknown;
+}
+
+export type UploadPhase = "start" | "uploading" | "complete" | "error";
+
+export interface UploadProgress {
+  phase: UploadPhase;
+  filename: string;
+  totalBytes: number;
+  bytesTransferred: number;
+  percent: number;
+  message?: string;
+}
+
+export interface UploadContext {
+  filePath: string;
+  apiKey?: string | null;
+  metadata?: Record<string, string>;
+  headers?: Record<string, string>;
+  onProgress?: ((progress: UploadProgress) => void) | null;
+  http: unknown;
+}
+
+export interface UploadAdapter {
+  upload(context: UploadContext): Promise<UploadResult>;
+}
+
+export interface UploadOptions {
+  platform?: string;
+  apiKey?: string;
+  metadata?: Record<string, string>;
+  headers?: Record<string, string>;
+  timeoutMs?: number;
+  onProgress?: (progress: UploadProgress) => void;
+}
+
+export interface UploadClientOptions {
+  platform?: string;
+  apiKey?: string;
+  timeoutMs?: number;
+}
+
+export declare class UploadClient {
+  constructor(options?: UploadClientOptions);
+  registerPlatform(name: string, adapter: UploadAdapter): this;
+  upload(filePath: string, options?: UploadOptions): Promise<UploadResult>;
+}
+
+export interface ShortenResult {
+  provider: string;
+  success: boolean;
+  shortUrl: string;
+  raw: unknown;
+}
+
+export interface VideoUploadResult {
+  provider: string;
+  success: boolean;
+  videoId: string | null;
+  watchUrl: string;
+  raw: unknown;
+}
+
+export interface ShorturlAdapter {
+  shorten(context: unknown): Promise<ShortenResult>;
+}
+
+export interface VideoProviderAdapter {
+  upload(context: unknown): Promise<VideoUploadResult>;
+}
+
+export interface DoodstreamProvider extends VideoProviderAdapter {
+  cloneFile(context: unknown): Promise<{ provider: "doodstream"; success: boolean; result: unknown; raw: unknown }>;
+  remoteUploadAdd(context: unknown): Promise<{ provider: "doodstream"; success: boolean; filecode: string | null; raw: unknown }>;
+  remoteUploadList(context: unknown): Promise<{ provider: "doodstream"; success: boolean; items: unknown[]; raw: unknown }>;
+  remoteUploadStatus(context: unknown): Promise<{ provider: "doodstream"; success: boolean; items: unknown[]; raw: unknown }>;
+  remoteUploadSlots(context: unknown): Promise<{
+    provider: "doodstream";
+    success: boolean;
+    totalSlots: string | null;
+    usedSlots: string | null;
+    raw: unknown;
+  }>;
+  remoteUploadActions(context: unknown): Promise<{ provider: "doodstream"; success: boolean; raw: unknown }>;
+}
+
+export interface UploadAndShortenResult {
+  success: true;
+  upload: UploadResult;
+  shortlink: ShortenResult;
+}
+
+export interface ShortenOptions {
+  provider?: string;
+  apiKey?: string;
+  preset?: string;
+  baseUrl?: string;
+  alias?: string;
+  adsType?: number;
+  responseFormat?: "json" | "text";
+  timeoutMs?: number;
+}
+
+export interface UploadAndShortenOptions {
+  uploadPlatform?: string;
+  uploadApiKey?: string;
+  uploadMetadata?: Record<string, string>;
+  uploadHeaders?: Record<string, string>;
+  shortenerProvider?: string;
+  shortenerApiKey?: string;
+  shortenerPreset?: string;
+  shortenerBaseUrl?: string;
+  alias?: string;
+  adsType?: number;
+  responseFormat?: "json" | "text";
+  timeoutMs?: number;
+  onProgress?: (progress: UploadProgress) => void;
+}
+
+export interface VideoUploadOptions {
+  provider?: string;
+  apiKey?: string;
+  metadata?: Record<string, string>;
+  timeoutMs?: number;
+  onProgress?: (progress: UploadProgress) => void;
+}
+
+export declare class EarningsClient {
+  constructor(options?: {
+    timeoutMs?: number;
+    upload?: UploadClientOptions;
+    uploadClient?: UploadClient;
+  });
+  registerShortener(name: string, adapter: { shorten(context: unknown): Promise<ShortenResult> }): this;
+  registerVideoProvider(name: string, adapter: { upload(context: unknown): Promise<VideoUploadResult> }): this;
+  shortenUrl(longUrl: string, options?: ShortenOptions): Promise<ShortenResult>;
+  uploadAndShorten(filePath: string, options?: UploadAndShortenOptions): Promise<UploadAndShortenResult>;
+  uploadVideo(filePath: string, options?: VideoUploadOptions): Promise<VideoUploadResult>;
+}
+
+export declare const platforms: {
+  upfiles: UploadAdapter;
+  fileio: UploadAdapter;
+  catbox: UploadAdapter;
+  transfersh: UploadAdapter;
+};
+
+export declare const shortenerPresets: Record<string, string>;
+
+export declare const upload: {
+  Client: typeof UploadClient;
+  providers: typeof platforms;
+};
+
+export declare const shorturl: {
+  providers: {
+    "adlinkfly-compatible": ShorturlAdapter;
+  };
+  presets: typeof shortenerPresets;
+};
+
+export declare const video: {
+  providers: {
+    doodstream: DoodstreamProvider;
+  };
+};
+
+export declare const earnings: {
+  Client: typeof EarningsClient;
+};

package/src/index.js

@@ -0,0 +1,25 @@
+const { UploadClient, providers: uploadProviders } = require("./upload/client");
+const { EarningsClient, shortenerPresets } = require("./earnings");
+const { providers: shorturlProviders } = require("./shorturl/providers");
+const videoProviders = require("./video/providers");
+
+module.exports = {
+  upload: {
+    Client: UploadClient,
+    providers: uploadProviders
+  },
+  shorturl: {
+    providers: shorturlProviders,
+    presets: shortenerPresets
+  },
+  video: {
+    providers: videoProviders
+  },
+  earnings: {
+    Client: EarningsClient
+  },
+  UploadClient,
+  platforms: uploadProviders,
+  EarningsClient,
+  shortenerPresets
+};

package/src/shorturl/provider/adlinkfly-compatible.js

@@ -0,0 +1,73 @@
+async function shorten(context) {
+  const { longUrl, apiKey, http, options } = context;
+  const baseUrl = options && options.baseUrl;
+  if (!baseUrl) {
+    throw new Error('Missing shortlink baseUrl for "adlinkfly-compatible" provider.');
+  }
+  if (!apiKey) {
+    throw new Error('Missing shortlink apiKey for "adlinkfly-compatible" provider.');
+  }
+
+  const params = {
+    api: apiKey,
+    url: longUrl
+  };
+
+  if (options.alias) {
+    params.alias = options.alias;
+  }
+  if (typeof options.adsType === "number") {
+    params.type = options.adsType;
+  }
+
+  const wantsText = options.responseFormat === "text";
+  if (!wantsText) {
+    params.format = "json";
+  } else {
+    params.format = "text";
+  }
+
+  const response = await http.get(baseUrl, { params });
+  const body = response.data;
+
+  if (wantsText) {
+    const shortUrl = String(body || "").trim();
+    if (!shortUrl || !/^https?:\/\//i.test(shortUrl)) {
+      throw new Error(shortUrl || "Shortlink provider returned invalid text response.");
+    }
+    return {
+      provider: options.provider || "adlinkfly-compatible",
+      success: true,
+      shortUrl,
+      raw: body
+    };
+  }
+
+  if (!body || body.status === "error") {
+    const message = normalizeErrorMessage(body && body.message);
+    throw new Error(message || "Shortlink provider returned an error.");
+  }
+
+  const shortUrl = body.shortenedUrl || body.shortened_url || body.shortened || body.url;
+  if (!shortUrl || !/^https?:\/\//i.test(String(shortUrl))) {
+    throw new Error("Shortlink provider did not return a valid short URL.");
+  }
+
+  return {
+    provider: options.provider || "adlinkfly-compatible",
+    success: true,
+    shortUrl: String(shortUrl),
+    raw: body
+  };
+}
+
+function normalizeErrorMessage(message) {
+  if (Array.isArray(message)) {
+    return message.join(", ");
+  }
+  return message ? String(message) : "";
+}
+
+module.exports = {
+  shorten
+};

package/src/shorturl/provider/presets.js

@@ -0,0 +1,37 @@
+const ADLINKFLY_BASE_URLS = {
+  adlinkflyDemo: "https://demo.adlinkfly.in/api",
+  shrtfly: "https://shrtfly.com/api",
+  exei: "https://exe.io/api",
+  shrinkme: "https://shrinkme.io/api",
+  shrinkearn: "https://shrinkearn.com/api",
+  clksh: "https://clk.sh/api",
+  lnkc: "https://lnk.cu/api",
+  zinkme: "https://zinkme.com/api",
+  short2url: "https://short2url.in/api",
+  urlnama: "https://url.namaidani.net/api",
+  adshorti: "https://adshorti.xyz/api",
+  shrtbr: "https://shrtbr.com/api",
+  linkmonetizado: "https://linkmonetizado.com/api",
+  clicksfly: "https://clicksfly.com/api",
+  urlsfly: "https://urlsfly.com/api",
+  wefly: "https://wefly.me/api",
+  adbull: "https://adbull.me/api",
+  linksly: "https://linksly.co/api",
+  droplink: "https://droplink.co/api",
+  adbitfly: "https://adbitfly.com/api",
+  earnlink: "https://earnlink.io/api",
+  easycut: "https://easycut.io/api",
+  megaurl: "https://megaurl.in/api",
+  shortzon: "https://shortzon.com/api",
+  shortiio: "https://shorti.io/api",
+  adlinkcash: "https://adlinkcash.com/api",
+  adlinkic: "https://adlinkic.com/api",
+  shorte: "https://shorte.st/api",
+  link1s: "https://link1s.com/st/api",
+  cutpay: "https://cutpay.xyz/api",
+  adz7short: "https://adz7short.space/api"
+};
+
+module.exports = {
+  ADLINKFLY_BASE_URLS
+};

package/src/shorturl/providers.js

@@ -0,0 +1,11 @@
+const adlinkflyCompatible = require("./provider/adlinkfly-compatible");
+const { ADLINKFLY_BASE_URLS } = require("./provider/presets");
+
+const providers = {
+  "adlinkfly-compatible": adlinkflyCompatible
+};
+
+module.exports = {
+  providers,
+  presets: ADLINKFLY_BASE_URLS
+};

package/src/upload/client.js

@@ -0,0 +1,57 @@
+const axios = require("axios");
+const providers = require("./providers");
+
+class UploadClient {
+  constructor(options = {}) {
+    this.defaultPlatform = options.platform || "upfiles";
+    this.defaultApiKey = options.apiKey || null;
+    this.timeoutMs = options.timeoutMs || 60000;
+    this.adapters = { ...providers };
+  }
+
+  registerPlatform(name, adapter) {
+    if (!name || typeof name !== "string") {
+      throw new Error("Platform name must be a non-empty string.");
+    }
+
+    if (!adapter || typeof adapter.upload !== "function") {
+      throw new Error("Adapter must provide an upload(context) function.");
+    }
+
+    this.adapters[name] = adapter;
+    return this;
+  }
+
+  async upload(filePath, options = {}) {
+    if (!filePath || typeof filePath !== "string") {
+      throw new Error("filePath is required and must be a string.");
+    }
+
+    const platform = options.platform || this.defaultPlatform;
+    const adapter = this.adapters[platform];
+    if (!adapter) {
+      throw new Error(
+        `Unsupported platform "${platform}". Registered: ${Object.keys(this.adapters).join(", ")}`
+      );
+    }
+
+    const apiKey = options.apiKey || this.defaultApiKey || null;
+    const timeoutMs = options.timeoutMs || this.timeoutMs;
+    const headers = options.headers || {};
+    const onProgress = typeof options.onProgress === "function" ? options.onProgress : null;
+
+    return adapter.upload({
+      filePath,
+      apiKey,
+      metadata: options.metadata || {},
+      headers,
+      http: axios.create({ timeout: timeoutMs }),
+      onProgress
+    });
+  }
+}
+
+module.exports = {
+  UploadClient,
+  providers
+};

package/src/upload/provider/catbox.js

@@ -0,0 +1,68 @@
+const FormData = require("form-data");
+const { createProgressFilePart } = require("../../utils/file");
+
+async function upload(context) {
+  const { filePath, apiKey, metadata, headers, http, onProgress } = context;
+
+  const form = new FormData();
+  const filePart = createProgressFilePart(filePath, onProgress);
+  form.append("reqtype", "fileupload");
+  if (apiKey) {
+    form.append("userhash", apiKey);
+  }
+  form.append("fileToUpload", filePart.stream, filePart.filename);
+
+  for (const [key, value] of Object.entries(metadata || {})) {
+    form.append(key, value);
+  }
+
+  let response;
+  try {
+    response = await http.post("https://catbox.moe/user/api.php", form, {
+      headers: {
+        ...form.getHeaders(),
+        ...headers
+      },
+      maxBodyLength: Infinity,
+      responseType: "text",
+      transformResponse: [(data) => data]
+    });
+  } catch (error) {
+    if (typeof onProgress === "function") {
+      onProgress({
+        phase: "error",
+        filename: filePart.filename,
+        totalBytes: filePart.totalBytes,
+        bytesTransferred: 0,
+        percent: 0,
+        message: error.message
+      });
+    }
+    throw error;
+  }
+
+  const raw = String(response.data || "").trim();
+  if (!raw || /^error/i.test(raw)) {
+    throw new Error(raw || "Catbox upload failed.");
+  }
+  if (typeof onProgress === "function") {
+    onProgress({
+      phase: "complete",
+      filename: filePart.filename,
+      totalBytes: filePart.totalBytes,
+      bytesTransferred: filePart.totalBytes,
+      percent: 100
+    });
+  }
+
+  return {
+    platform: "catbox",
+    success: true,
+    url: raw,
+    raw
+  };
+}
+
+module.exports = {
+  upload
+};

package/src/upload/provider/fileio.js

@@ -0,0 +1,64 @@
+const FormData = require("form-data");
+const { createProgressFilePart } = require("../../utils/file");
+
+async function upload(context) {
+  const { filePath, metadata, headers, http, onProgress } = context;
+
+  const form = new FormData();
+  const filePart = createProgressFilePart(filePath, onProgress);
+  form.append("file", filePart.stream, filePart.filename);
+
+  if (metadata.expires) {
+    form.append("expires", metadata.expires);
+  }
+
+  let response;
+  try {
+    response = await http.post("https://file.io", form, {
+      headers: {
+        ...form.getHeaders(),
+        ...headers
+      },
+      maxBodyLength: Infinity
+    });
+  } catch (error) {
+    if (typeof onProgress === "function") {
+      onProgress({
+        phase: "error",
+        filename: filePart.filename,
+        totalBytes: filePart.totalBytes,
+        bytesTransferred: 0,
+        percent: 0,
+        message: error.message
+      });
+    }
+    throw error;
+  }
+
+  const body = response.data || {};
+  const link = body.link || body.url;
+  const success = Boolean(body.success && link);
+  if (!success) {
+    throw new Error(body.message || "file.io upload failed.");
+  }
+  if (typeof onProgress === "function") {
+    onProgress({
+      phase: "complete",
+      filename: filePart.filename,
+      totalBytes: filePart.totalBytes,
+      bytesTransferred: filePart.totalBytes,
+      percent: 100
+    });
+  }
+
+  return {
+    platform: "fileio",
+    success: true,
+    url: link,
+    raw: body
+  };
+}
+
+module.exports = {
+  upload
+};

package/src/upload/provider/transfersh.js

@@ -0,0 +1,58 @@
+const path = require("path");
+const { createProgressFilePart } = require("../../utils/file");
+
+async function upload(context) {
+  const { filePath, headers, http, onProgress } = context;
+  const filePart = createProgressFilePart(filePath, onProgress);
+  const fileName = encodeURIComponent(path.basename(filePath));
+
+  let response;
+  try {
+    response = await http.put(`https://transfer.sh/${fileName}`, filePart.stream, {
+      headers: {
+        "Content-Type": "application/octet-stream",
+        ...headers
+      },
+      maxBodyLength: Infinity,
+      responseType: "text",
+      transformResponse: [(data) => data]
+    });
+  } catch (error) {
+    if (typeof onProgress === "function") {
+      onProgress({
+        phase: "error",
+        filename: filePart.filename,
+        totalBytes: filePart.totalBytes,
+        bytesTransferred: 0,
+        percent: 0,
+        message: error.message
+      });
+    }
+    throw error;
+  }
+
+  const raw = String(response.data || "").trim();
+  if (!raw || !/^https?:\/\//i.test(raw)) {
+    throw new Error(raw || "transfer.sh upload failed.");
+  }
+  if (typeof onProgress === "function") {
+    onProgress({
+      phase: "complete",
+      filename: filePart.filename,
+      totalBytes: filePart.totalBytes,
+      bytesTransferred: filePart.totalBytes,
+      percent: 100
+    });
+  }
+
+  return {
+    platform: "transfersh",
+    success: true,
+    url: raw,
+    raw
+  };
+}
+
+module.exports = {
+  upload
+};

package/src/upload/provider/upfiles.js

@@ -0,0 +1,67 @@
+const FormData = require("form-data");
+const { createProgressFilePart } = require("../../utils/file");
+
+async function upload(context) {
+  const { filePath, apiKey, metadata, headers, http, onProgress } = context;
+
+  if (!apiKey) {
+    throw new Error('Missing apiKey for "upfiles". Pass apiKey in client config or upload options.');
+  }
+
+  const form = new FormData();
+  const filePart = createProgressFilePart(filePath, onProgress);
+  form.append("token", apiKey);
+  form.append("file", filePart.stream, filePart.filename);
+
+  for (const [key, value] of Object.entries(metadata || {})) {
+    form.append(key, value);
+  }
+  let response;
+  try {
+    response = await http.post("https://api.upfiles.com/upload", form, {
+      headers: {
+        ...form.getHeaders(),
+        ...headers
+      },
+      maxBodyLength: Infinity
+    });
+  } catch (error) {
+    if (typeof onProgress === "function") {
+      onProgress({
+        phase: "error",
+        filename: filePart.filename,
+        totalBytes: filePart.totalBytes,
+        bytesTransferred: 0,
+        percent: 0,
+        message: error.message
+      });
+    }
+    throw error;
+  }
+
+  const body = response.data || {};
+  const success = body.status === "success" && Boolean(body.url);
+  if (!success) {
+    throw new Error(body.message || "UpFiles upload failed.");
+  }
+  if (typeof onProgress === "function") {
+    onProgress({
+      phase: "complete",
+      filename: filePart.filename,
+      totalBytes: filePart.totalBytes,
+      bytesTransferred: filePart.totalBytes,
+      percent: 100
+    });
+  }
+
+  return {
+    platform: "upfiles",
+    success: true,
+    url: body.url,
+    raw: body
+  };
+}
+
+module.exports = {
+  upload
+};

package/src/upload/providers.js

@@ -0,0 +1,11 @@
+const upfiles = require("./provider/upfiles");
+const fileio = require("./provider/fileio");
+const catbox = require("./provider/catbox");
+const transfersh = require("./provider/transfersh");
+
+module.exports = {
+  upfiles,
+  fileio,
+  catbox,
+  transfersh
+};

package/src/upload-client.js

@@ -0,0 +1 @@
+module.exports = require("./upload/client");