@zibot/scdl 0.0.5 → 0.1.0

package/.prettierrc

@@ -0,0 +1,21 @@
+{
+	"arrowParens": "always",
+	"bracketSameLine": true,
+	"bracketSpacing": true,
+	"semi": true,
+	"experimentalTernaries": true,
+	"singleQuote": false,
+	"jsxSingleQuote": true,
+	"quoteProps": "as-needed",
+	"trailingComma": "all",
+	"singleAttributePerLine": true,
+	"htmlWhitespaceSensitivity": "css",
+	"vueIndentScriptAndStyle": false,
+	"proseWrap": "always",
+	"insertPragma": false,
+	"printWidth": 130,
+	"requirePragma": false,
+	"tabWidth": 2,
+	"useTabs": true,
+	"embeddedLanguageFormatting": "auto"
+}

package/README.md

@@ -1,118 +1,335 @@
 # @zibot/scdl
 
-@zibot/scdl là một module JavaScript hỗ trợ tải, tìm kiếm, và quản lý dữ liệu từ SoundCloud thông qua API. Module này cung cấp các
-phương thức tiện lợi để xử lý track, playlist, và tải nội dung.
+A tiny, promise-based Node.js client for searching SoundCloud, fetching track/playlist details, and downloading tracks as readable streams.
 
-## Cài đặt
+* **Search** tracks, playlists, and users
+* **Inspect** rich metadata for tracks and playlists
+* **Download** a track stream (high/low quality)
+* **Discover** related tracks by URL or ID
 
-Bạn có thể cài đặt module này bằng npm hoặc yarn:
+> ⚠️ Respect SoundCloud’s Terms of Service and creator rights. This library is for personal/educational use; don’t redistribute copyrighted content without permission.
 
-```bash
-npm install @zibot/scdl
-```
+---
 
-hoặc
+## Installation
 
 ```bash
+npm i @zibot/scdl
+# or
 yarn add @zibot/scdl
+# or
+pnpm add @zibot/scdl
 ```
 
-## Sử dụng
+**Runtime:** Node.js 18+ is recommended (built-in `fetch`/WHATWG streams). Works with ESM or CommonJS.
+
+---
+
+## Quick Start
+
+### ESM
+
+```ts
+import SoundCloud from "@zibot/scdl";
+
+const sc = new SoundCloud({ init: true }); // auto-initialize clientId
+
+(async () => {
+  // Search tracks
+  const results = await sc.searchTracks({ query: "lofi hip hop", limit: 5, type: "tracks" });
+  console.log(results);
+
+  // Track details
+  const track = await sc.getTrackDetails("https://soundcloud.com/user/track-slug");
+  console.log(track.title, track.user.username);
+
+  // Download a track (Readable stream)
+  const stream = await sc.downloadTrack("https://soundcloud.com/user/track-slug", { quality: "high" });
+  stream.pipe(process.stdout); // or pipe to fs.createWriteStream("track.mp3")
+
+  // Related tracks
+  const related = await sc.getRelatedTracks(track.id, { limit: 10 });
+  console.log(related.map(t => t.title));
+})();
+```
 
-### Khởi tạo
+### CommonJS
 
-Đầu tiên, bạn cần khởi tạo lớp `SoundCloud` để sử dụng các chức năng của module:
+```js
+const SoundCloud = require("@zibot/scdl");
+const fs = require("node:fs");
 
-```javascript
-const { SoundCloud } = require("@zibot/scdl");
+const sc = new SoundCloud({ init: true });
 
 (async () => {
-	const scdl = new SoundCloud({ init: true }); // Tự động lấy client ID
-	await scdl.init(); // Đảm bảo client ID được khởi tạo
+  const stream = await sc.downloadTrack("https://soundcloud.com/user/track-slug");
+  stream.pipe(fs.createWriteStream("track.mp3"));
 })();
 ```
 
 ---
 
-### Các phương thức
+## Initialization
 
-#### **`searchTracks(options)`**
+The client can retrieve a valid `clientId` automatically.
 
-Tìm kiếm các track trên SoundCloud.
+```ts
+// Option A: auto-init (recommended)
+const sc = new SoundCloud({ init: true });
 
-```javascript
-const tracks = await scdl.searchTracks({ query: "chill", limit: 5 });
-console.log(tracks);
+// Option B: manual init
+const sc = new SoundCloud();
+await sc.init(); // retrieves clientId
 ```
 
-**Tham số:**
+> You usually only need to call `init()` once per process. If you get authentication errors later, re-calling `init()` may refresh the client ID.
+
+---
+
+## API
+
+### `new SoundCloud(options?)`
 
-- `query` (bắt buộc): Từ khóa để tìm kiếm.
-- `limit` (mặc định: `20`): Số lượng track tối đa.
-- `offset` (mặc định: `0`): Vị trí bắt đầu.
+Create a client.
+
+* `options.init?: boolean` – if `true`, calls `init()` internally.
+
+**Properties**
+
+* `clientId: string | null` – resolved after `init()`
+* `apiBaseUrl: string` – internal base URL used for API calls
+
+---
+
+### `init(): Promise<void>`
+
+Initialize the client (retrieve `clientId`). Call this if you didn’t pass `{ init: true }`.
 
 ---
 
-#### **`getTrack(url)`**
+### `searchTracks(options: SearchOptions): Promise<(Track | Playlist | User)[]>`
+
+Search SoundCloud.
+
+**Parameters – `SearchOptions`**
+
+* `query: string` – search text
+* `limit?: number` – default depends on endpoint (commonly 10–20)
+* `offset?: number` – for pagination
+* `type?: "all" | "tracks" | "playlists" | "users"` – filter result kinds (default `"all"`)
 
-Lấy thông tin chi tiết về một track.
+**Usage**
 
-```javascript
-const track = await scdl.getTrack("https://soundcloud.com/user/song");
-console.log(track);
+```ts
+// Top tracks
+const tracks = await sc.searchTracks({ query: "ambient study", type: "tracks", limit: 10 });
+
+// Mixed kinds (tracks/playlists/users)
+const mixed = await sc.searchTracks({ query: "chill", type: "all", limit: 5, offset: 5 });
 ```
 
-**Tham số:**
+---
+
+### `getTrackDetails(url: string): Promise<Track>`
+
+Get rich metadata for a single track by its public URL.
+
+```ts
+const t = await sc.getTrackDetails("https://soundcloud.com/artist/track");
+console.log({
+  id: t.id,
+  title: t.title,
+  by: t.user.username,
+  streamables: t.media.transcodings.length,
+});
+```
 
-- `url` (bắt buộc): URL của track.
+**`Track`**
+
+```ts
+interface Track {
+  id: number;
+  title: string;
+  url: string;
+  user: { id: number; username: string };
+  media: {
+    transcodings: {
+      url: string;
+      format: { protocol: string; mime_type: string };
+    }[];
+  };
+}
+```
 
 ---
 
-#### **`getPlaylist(url)`**
+### `getPlaylistDetails(url: string): Promise<Playlist>`
 
-Lấy thông tin chi tiết về một playlist.
+Fetch playlist metadata and contained tracks.
 
-```javascript
-const playlist = await scdl.getPlaylist("https://soundcloud.com/user/playlist");
-console.log(playlist);
+```ts
+const pl = await sc.getPlaylistDetails("https://soundcloud.com/artist/sets/playlist-slug");
+console.log(pl.title, pl.tracks.length);
 ```
 
-**Tham số:**
+**`Playlist`**
 
-- `url` (bắt buộc): URL của playlist.
+```ts
+interface Playlist {
+  id: number;
+  title: string;
+  tracks: Track[];
+}
+```
 
 ---
 
-#### **`downloadTrack(url, options)`**
+### `downloadTrack(url: string, options?: DownloadOptions): Promise<Readable>`
+
+Download a track as a Node `Readable` stream.
+
+**Parameters – `DownloadOptions`**
 
-Tải một track từ SoundCloud.
+* `quality?: "high" | "low"` – choose available transcoding (default implementation prefers higher quality when available)
 
-```javascript
-const stream = await scdl.downloadTrack("https://soundcloud.com/user/song");
-stream.pipe(fs.createWriteStream("track.mp3"));
+**Examples**
+
+```ts
+import fs from "node:fs";
+
+const read = await sc.downloadTrack("https://soundcloud.com/user/track", { quality: "high" });
+await new Promise((resolve, reject) => {
+  read.pipe(fs.createWriteStream("track.mp3"))
+    .on("finish", resolve)
+    .on("error", reject);
+});
+```
+
+Pipe to any writable destination (stdout, HTTP response, cloud storage SDKs, etc.).
+
+---
+
+### `getRelatedTracks(track: string | number, opts?: { limit?: number; offset?: number }): Promise<Track[]>`
+
+Fetch tracks related to a given track by **URL** or **numeric ID**.
+
+```ts
+// by URL
+const relByUrl = await sc.getRelatedTracks("https://soundcloud.com/artist/track", { limit: 6 });
+
+// by ID
+const base = await sc.getTrackDetails("https://soundcloud.com/artist/track");
+const relById = await sc.getRelatedTracks(base.id, { limit: 6 });
 ```
 
-**Tham số:**
+---
+
+## Types
+
+```ts
+export interface SearchOptions {
+  query: string;
+  limit?: number;
+  offset?: number;
+  type?: "all" | "tracks" | "playlists" | "users";
+}
+
+export interface DownloadOptions {
+  quality?: "high" | "low";
+}
+
+export interface User {
+  id: number;
+  username: string;
+  followers_count: number;
+  track_count: number;
+}
+```
 
-- `url` (bắt buộc): URL của track.
-- `options` (tùy chọn): Cấu hình tải xuống.
+These types are exported for TypeScript consumers.
 
 ---
 
-### Lưu ý
+## Examples
+
+### Save the highest-quality stream to disk
+
+```ts
+import fs from "node:fs";
+import SoundCloud from "@zibot/scdl";
+
+const sc = new SoundCloud({ init: true });
+
+async function save(url: string, file: string) {
+  const stream = await sc.downloadTrack(url, { quality: "high" });
+  await new Promise<void>((resolve, reject) => {
+    stream.pipe(fs.createWriteStream(file))
+      .on("finish", resolve)
+      .on("error", reject);
+  });
+}
+
+save("https://soundcloud.com/user/track", "output.mp3");
+```
+
+### Basic search → pick first result → download
+
+```ts
+const [first] = await sc.searchTracks({ query: "deep house 2024", type: "tracks", limit: 1 });
+if (first && "url" in first) {
+  const s = await sc.downloadTrack(first.url);
+  s.pipe(process.stdout);
+}
+```
+
+### Paginate results
+
+```ts
+const page1 = await sc.searchTracks({ query: "vaporwave", type: "tracks", limit: 20, offset: 0 });
+const page2 = await sc.searchTracks({ query: "vaporwave", type: "tracks", limit: 20, offset: 20 });
+```
+
+---
+
+## Error Handling & Tips
+
+* **Initialization:** If a method throws due to missing/expired `clientId`, call `await sc.init()` and retry.
+* **Quality selection:** Not all tracks expose multiple transcodings; the library will fall back when needed.
+* **Rate limits / 429:** Back off and retry with an exponential strategy.
+* **Private/geo-restricted tracks:** Details/downloads may be unavailable.
+* **Networking:** Wrap downloads with proper error and close handlers to avoid dangling file descriptors.
+
+---
+
+## FAQ
+
+**Q: Can I use this in the browser?**
+This package targets Node.js (it returns Node `Readable`). Browser use is not supported.
+
+**Q: What audio format do I get?**
+Whatever the selected transcoding provides (commonly progressive MP3 or HLS AAC). You may need to remux/encode if you require a specific container/codec.
+
+**Q: Do I need my own client ID?**
+The client auto-discovers a valid `clientId`. If discovery fails due to upstream changes, update the package to the latest version.
+
+---
+
+## Contributing
+
+PRs and issues are welcome! Please include:
 
-- Trước khi sử dụng các phương thức như `searchTracks`, `getTrack`, hoặc `downloadTrack`, cần đảm bảo rằng phương thức `init()` đã
-  hoàn thành để lấy `clientId`.
-- Nếu `clientId` không được khởi tạo, các phương thức này sẽ ném lỗi.
+* A clear description of the change
+* Repro steps (for bugs)
+* Tests where possible
 
 ---
 
-## Đóng góp
+## License
 
-Nếu bạn muốn đóng góp cho dự án này, vui lòng tạo một pull request hoặc mở một issue trên GitHub.
+MIT © Zibot
 
 ---
 
-## Giấy phép
+## Disclaimer
 
-Dự án này được cấp phép theo giấy phép MIT. Xem file [LICENSE](LICENSE) để biết thêm chi tiết.
+This project is not affiliated with SoundCloud. Use responsibly and comply with all applicable laws and SoundCloud’s Terms of Service.

package/index.js

@@ -6,11 +6,11 @@ const m3u8stream = require("m3u8stream");
 class SoundCloud {
 	/**
 	 * @param {Object} options
-	 * @param {boolean} [options.autoInit=true] - tự động lấy clientId
+	 * @param {boolean} [options.autoInit=true]
 	 * @param {string}  [options.apiBaseUrl="https://api-v2.soundcloud.com"]
 	 * @param {number}  [options.timeout=12_000]
-	 * @param {(id:string)=>void} [options.onClientId] - callback khi lấy được clientId (để cache ngoài)
-	 * @param {string}  [options.clientId] - nếu bạn đã có sẵn clientId hợp lệ
+	 * @param {(id:string)=>void} [options.onClientId]
+	 * @param {string}  [options.clientId]
 	 */
 	constructor(options = {}) {
 		const defaultOptions = {
@@ -23,6 +23,7 @@ class SoundCloud {
 		this.opts = { ...defaultOptions, ...options };
 		this.apiBaseUrl = this.opts.apiBaseUrl;
 		this.clientId = this.opts.clientId || null;
+		this.appVersion = null; // Will be fetched during init
 
 		this.http = axios.create({
 			timeout: this.opts.timeout,
@@ -40,16 +41,19 @@ class SoundCloud {
 	}
 
 	async ensureReady() {
-		if (this.clientId) return;
+		if (this.clientId && this.appVersion) return;
 		if (!this._initPromise) this._initPromise = this.init();
 		await this._initPromise;
 	}
 
 	async _getJson(url, { retries = 3, retryOn = [429, 500, 502, 503, 504] } = {}) {
+		const separator = url.includes("?") ? "&" : "?";
+		const finalUrl = this.appVersion ? `${url}${separator}app_version=${this.appVersion}` : url;
+
 		let lastErr;
 		for (let attempt = 0; attempt <= retries; attempt++) {
 			try {
-				const { data } = await this.http.get(url);
+				const { data } = await this.http.get(finalUrl);
 				return data;
 			} catch (err) {
 				lastErr = err;
@@ -64,41 +68,60 @@ class SoundCloud {
 	}
 
 	async init() {
-		if (this.clientId) return this.clientId;
+		if (this.clientId && this.appVersion) return this.clientId;
 
-		const regexes = [
-			/client_id=([a-zA-Z0-9]{32})/g, // client_id=XXXXXXXX...
-			/"client_id"\s*:\s*"([a-zA-Z0-9]{32})"/g, // "client_id":"XXXXXXXX..."
+		const clientRegexes = [
+			/client_id=([a-zA-Z0-9]{32})/g,
+			/client_id:"([a-zA-Z0-9]{32})"/,
+			/"client_id"\s*:\s*"([a-zA-Z0-9]{32})"/g,
 		];
+		const versionRegex = /"app_version"\s*:\s*"([^"]+)"/;
+
+		const homeHtml = await this.http
+			.get("https://soundcloud.com")
+			.then((r) => r.data)
+			.catch(() => null);
+
+		// Attempt to extract app_version from home HTML first
+		if (homeHtml && versionRegex.test(homeHtml)) {
+			this.appVersion = homeHtml.match(versionRegex)[1];
+		}
 
-		const homeHtml = await this._getJson("https://soundcloud.com").catch(() => null);
 		const scriptUrls =
-			(typeof homeHtml === "string"
-				? (homeHtml.match(/<script[^>]+src="([^"]+)"/g) || []).map((t) => t.match(/src="([^"]+)"/)?.[1]).filter(Boolean)
-				: []) || [];
+			(typeof homeHtml === "string" ?
+				(homeHtml.match(/<script[^>]+src="([^"]+)"/g) || []).map((t) => t.match(/src="([^"]+)"/)?.[1]).filter(Boolean)
+			:	[]) || [];
 
 		const candidates = [
 			...scriptUrls.filter((u) => /sndcdn\.com|soundcloud\.com/.test(u)),
 			"https://a-v2.sndcdn.com/assets/1-ff6b3.js",
-			"https://a-v2.sndcdn.com/assets/2-ff6b3.js",
 		];
 
 		for (const url of candidates) {
 			try {
 				const res = await this.http.get(url, { responseType: "text" });
 				const text = res.data || "";
-				for (const re of regexes) {
+
+				if (!this.appVersion && versionRegex.test(text)) {
+					this.appVersion = text.match(versionRegex)[1];
+				}
+
+				for (const re of clientRegexes) {
 					const m = re.exec(text);
 					if (m && m[1]) {
 						this.clientId = m[1];
 						if (typeof this.opts.onClientId === "function") this.opts.onClientId(this.clientId);
-						return this.clientId;
 					}
 				}
+				if (this.clientId && this.appVersion) break;
 			} catch {}
 		}
 
-		throw new Error("Không thể lấy client_id từ SoundCloud");
+		// Fallback app_version if not found
+		if (!this.appVersion) this.appVersion = Math.floor(Date.now() / 1000).toString();
+		if (!this.clientId) throw new Error("Không thể lấy client_id từ SoundCloud");
+
+		return this.clientId;
 	}
 
 	async searchTracks({ query, limit = 30, offset = 0, type = "all" }) {
@@ -143,35 +166,59 @@ class SoundCloud {
 		return playlist;
 	}
 
-	async downloadTrack(trackUrl, options = {}) {
+	async downloadTrack(trackOrPlaylistUrl, options = {}) {
 		await this.ensureReady();
 		try {
-			const track = await this.getTrackDetails(trackUrl);
+			let item = await this.fetchItem(trackOrPlaylistUrl);
 
-			if (track?.policy === "BLOCK" || track?.state === "blocked") {
-				throw new Error("Track bị chặn (policy/geo).");
+			let track;
+			if (item.kind === "playlist") {
+				console.log(`[SoundCloud] Đã nhận diện link Set/Playlist: ${item.title}`);
+				if (!item.tracks || item.tracks.length === 0) {
+					throw new Error("Playlist này không có bài hát nào.");
+				}
+				track = item.tracks[0];
+
+				if (!track.media) {
+					track = await this.getTrackDetails(track.permalink_url || track.id);
+				}
+			} else if (item.kind === "track") {
+				track = item;
+			} else {
+				throw new Error("URL không phải là bài hát hoặc playlist hợp lệ.");
 			}
-			if (track?.has_downloads === false && track?.streamable === false) {
-				throw new Error("Track không cho phép stream.");
+
+			if (track?.policy === "BLOCK" || track?.state === "blocked") {
+				throw new Error(`Bài hát "${track.title}" bị chặn.`);
 			}
 
-			const transcoding = this._pickBestTranscoding(track);
-			if (!transcoding) throw new Error("Không tìm thấy stream phù hợp.");
-
-			const streamUrl = await this.getStreamUrl(transcoding.url);
-			if (transcoding.format?.protocol === "hls") {
-				return m3u8stream(streamUrl, {
-					requestOptions: {
-						headers: { "User-Agent": this.http.defaults.headers["User-Agent"] },
-					},
-					...options,
-				});
-			} else {
-				const res = await this.http.get(streamUrl, { responseType: "stream" });
-				return res.data;
+			const transcodings = this._getSortedTranscodings(track);
+			if (!transcodings.length) throw new Error("Không tìm thấy stream phù hợp cho bài này.");
+
+			for (const transcoding of transcodings) {
+				try {
+					const streamUrl = await this.getStreamUrl(transcoding.url);
+					if (transcoding.format?.protocol === "hls") {
+						return m3u8stream(streamUrl, {
+							requestOptions: {
+								headers: {
+									"User-Agent": this.http.defaults.headers["User-Agent"],
+									Referer: "https://soundcloud.com/",
+								},
+							},
+							...options,
+						});
+					} else {
+						const res = await this.http.get(streamUrl, { responseType: "stream" });
+						return res.data;
+					}
+				} catch (err) {
+					continue; // Thử định dạng tiếp theo nếu định dạng này lỗi
+				}
 			}
+			throw new Error("Không thể khởi tạo luồng tải cho tất cả định dạng.");
 		} catch (e) {
-			console.error("Failed to download track:", e?.message || e);
+			console.error("Failed to download:", e?.message || e);
 			return null;
 		}
 	}
@@ -203,11 +250,6 @@ class SoundCloud {
 			);
 			return results.flat();
 		} catch (error) {
-			console.error("Failed to fetch tracks by IDs:", {
-				clientId: this.clientId,
-				status: error?.response?.status,
-				error: error?.response?.data || error?.message,
-			});
 			throw new Error("Failed to fetch tracks by IDs");
 		}
 	}
@@ -229,26 +271,41 @@ class SoundCloud {
 				if (!data?.url) throw new Error("No stream URL in response (after refresh)");
 				return data.url;
 			}
-			throw new Error("Failed to fetch stream URL");
+			throw error;
 		}
 	}
 
-	/** pick transcoding: HLS (opus > mp3), fallback progressive mp3 */
-	_pickBestTranscoding(track) {
+	_getSortedTranscodings(track) {
 		const list = Array.isArray(track?.media?.transcodings) ? track.media.transcodings : [];
-		if (!list.length) return null;
 
 		const score = (t) => {
+			let s = 0;
 			const proto = t?.format?.protocol;
 			const mime = t?.format?.mime_type || "";
-			if (proto === "hls" && mime.includes("opus")) return 100;
-			if (proto === "hls" && mime.includes("mpeg")) return 90;
-			if (proto === "progressive" && mime.includes("mpeg")) return 70;
-			return 10;
+			const isLegacy = t?.is_legacy_transcoding;
+
+			// Priority 1: Modern transcodings (aac_160k, etc.)
+			if (isLegacy === false) s += 1000;
+
+			// Priority 2: Protocol (HLS generally preferred for performance)
+			if (proto === "hls") s += 100;
+			else if (proto === "progressive") s += 50;
+
+			// Priority 3: Codec quality
+			if (mime.includes("opus")) s += 30;
+			if (mime.includes("mp4") || mime.includes("aac")) s += 25;
+			if (mime.includes("mpeg")) s += 10;
+
+			return s;
 		};
 
-		return [...list].sort((a, b) => score(b) - score(a))[0];
+		return [...list].sort((a, b) => score(b) - score(a));
 	}
+
+	_pickBestTranscoding(track) {
+		return this._getSortedTranscodings(track)[0] || null;
+	}
+
 	async _resolveTrackId(input) {
 		await this.ensureReady();
 		if (!input) throw new Error("Missing track identifier");
@@ -262,23 +319,17 @@ class SoundCloud {
 		return item.id;
 	}
 
-	/**
-	 * Lấy danh sách related tracks cho một track (URL hoặc ID)
-	 * @param {string|number} track - track URL hoặc track ID
-	 * @param {object} opts
-	 * @param {number} [opts.limit=20]
-	 * @param {number} [opts.offset=0]
-	 * @returns {Promise<Array>} danh sách track tương tự
-	 */
 	async getRelatedTracks(track, { limit = 20, offset = 0 } = {}) {
 		await this.ensureReady();
 		const id = await this._resolveTrackId(track);
-
 		const url = `${this.apiBaseUrl}/tracks/${id}/related` + `?limit=${limit}&offset=${offset}&client_id=${this.clientId}`;
 
 		try {
 			const data = await this._getJson(url);
-			const collection = Array.isArray(data?.collection) ? data.collection : Array.isArray(data) ? data : [];
+			const collection =
+				Array.isArray(data?.collection) ? data.collection
+				: Array.isArray(data) ? data
+				: [];
 			return collection.filter((t) => t?.permalink_url && t?.title && t?.duration);
 		} catch (e) {
 			return [];

package/package.json

@@ -1,35 +1,32 @@
-{
-	"name": "@zibot/scdl",
-	"version": "0.0.5",
-	"description": "Soucloud download",
-	"main": "index.js",
-	"types": "index.d.ts",
-	"scripts": {
-		"test": "echo \"Error: no test specified\" && exit 1"
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/zijipia/Zibot_Package.git"
-	},
-	"keywords": [
-		"@zibot/scdl",
-		"scdl"
-	],
-	"author": "Ziji",
-	"license": "ISC",
-	"bugs": {
-		"url": "https://github.com/zijipia/Zibot_Package/issues"
-	},
-	"publishConfig": {
-		"access": "public"
-	},
-	"homepage": "https://github.com/zijipia/Zibot_Package#readme",
-	"devDependencies": {
-		"discord.js": "^14.16.3"
-	},
-	"dependencies": {
-		"axios": "^1.7.7",
-		"events": "^3.3.0",
-		"m3u8stream": "^0.8.6"
-	}
-}
+{
+	"name": "@zibot/scdl",
+	"version": "0.1.0",
+	"description": "Soucloud download",
+	"main": "index.js",
+	"types": "index.d.ts",
+	"scripts": {
+		"test": "echo \"Error: no test specified\" && exit 1"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/ZiProject/scdl.git"
+	},
+	"keywords": [
+		"@zibot/scdl",
+		"scdl"
+	],
+	"author": "Ziji",
+	"license": "ISC",
+	"bugs": {
+		"url": "https://github.com/ZiProject/scdl/issues"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"homepage": "https://github.com/ZiProject/scdl#readme",
+	"dependencies": {
+		"axios": "^1.13.2",
+		"events": "^3.3.0",
+		"m3u8stream": "^0.8.6"
+	}
+}

package/test.js

@@ -0,0 +1,37 @@
+const SoundCloud = require("./index.js");
+const fs = require("node:fs");
+const { pipeline } = require("node:stream/promises");
+
+const sc = new SoundCloud();
+
+(async () => {
+	try {
+		console.log("Đang khởi tạo và lấy stream...");
+		const url = "https://soundcloud.com/jar-chow-794199690/etoilesong-by-vermementomori-ost";
+
+		const stream = await sc.downloadTrack(url);
+
+		if (!stream) {
+			console.error("Không lấy được stream.");
+			return;
+		}
+
+		const filename = "track.ts"; // HLS thường là định dạng MPEG-TS
+		const writeStream = fs.createWriteStream(filename);
+
+		console.log("Đang tải dữ liệu...");
+
+		// Theo dõi tiến trình (optional)
+		let downloaded = 0;
+		stream.on("data", (chunk) => {
+			downloaded += chunk.length;
+			process.stdout.write(`\rĐã tải: ${(downloaded / 1024).toFixed(2)} KB`);
+		});
+
+		await pipeline(stream, writeStream);
+
+		console.log(`\n✅ Tải xong! File lưu tại: ${filename}`);
+	} catch (err) {
+		console.error("\n❌ Lỗi trong quá trình tải:", err.message);
+	}
+})();