neteasecli 2.0.0

package/dist/player/mpv.d.ts

@@ -0,0 +1,26 @@
+declare class MpvPlayer {
+    private requestId;
+    play(url: string, title?: string): Promise<void>;
+    pause(): Promise<void>;
+    seek(seconds: number, mode?: 'relative' | 'absolute'): Promise<void>;
+    setVolume(volume: number): Promise<void>;
+    getVolume(): Promise<number>;
+    setLoop(mode: 'no' | 'inf' | 'force'): Promise<void>;
+    getLoop(): Promise<string>;
+    stop(): Promise<void>;
+    getStatus(): Promise<{
+        title?: string;
+        position: number;
+        duration: number;
+        paused: boolean;
+        playing: boolean;
+        volume: number;
+        loop: string;
+    }>;
+    isRunning(): Promise<boolean>;
+    private getProperty;
+    private setProperty;
+    private sendCommand;
+}
+export declare const mpvPlayer: MpvPlayer;
+export {};

package/dist/player/mpv.js

@@ -0,0 +1,160 @@
+import { spawn } from 'child_process';
+import * as net from 'net';
+import * as fs from 'fs';
+const SOCKET_PATH = process.platform === 'win32' ? '\\\\.\\pipe\\neteasecli-mpv' : '/tmp/neteasecli-mpv.sock';
+class MpvPlayer {
+    requestId = 0;
+    async play(url, title) {
+        // Stop any existing instance
+        await this.stop().catch(() => { });
+        // Clean up stale socket file
+        if (process.platform !== 'win32' && fs.existsSync(SOCKET_PATH)) {
+            fs.unlinkSync(SOCKET_PATH);
+        }
+        return new Promise((resolve, reject) => {
+            const proc = spawn('mpv', [
+                '--no-video',
+                `--input-ipc-server=${SOCKET_PATH}`,
+                `--title=${title || 'neteasecli'}`,
+                url,
+            ], {
+                stdio: 'ignore',
+                detached: true,
+            });
+            proc.unref();
+            proc.on('error', (err) => {
+                reject(new Error(`Failed to start mpv: ${err.message}`));
+            });
+            // Wait for socket to become available
+            let attempts = 0;
+            const waitForSocket = () => {
+                attempts++;
+                const sock = net.createConnection(SOCKET_PATH);
+                sock.on('connect', () => {
+                    sock.destroy();
+                    resolve();
+                });
+                sock.on('error', () => {
+                    sock.destroy();
+                    if (attempts < 10) {
+                        setTimeout(waitForSocket, 200);
+                    }
+                    else {
+                        reject(new Error('mpv started but IPC socket not available'));
+                    }
+                });
+            };
+            setTimeout(waitForSocket, 300);
+        });
+    }
+    async pause() {
+        await this.sendCommand(['cycle', 'pause']);
+    }
+    async seek(seconds, mode = 'relative') {
+        await this.sendCommand(['seek', String(seconds), mode]);
+    }
+    async setVolume(volume) {
+        await this.setProperty('volume', Math.max(0, Math.min(150, volume)));
+    }
+    async getVolume() {
+        const vol = await this.getProperty('volume').catch(() => 100);
+        return Number(vol) || 100;
+    }
+    async setLoop(mode) {
+        await this.setProperty('loop-file', mode);
+    }
+    async getLoop() {
+        const loop = await this.getProperty('loop-file').catch(() => 'no');
+        return String(loop);
+    }
+    async stop() {
+        try {
+            await this.sendCommand(['quit']);
+        }
+        catch {
+            // mpv not running, ignore
+        }
+    }
+    async getStatus() {
+        try {
+            const [position, duration, paused, volume, loop, title] = await Promise.all([
+                this.getProperty('time-pos').catch(() => 0),
+                this.getProperty('duration').catch(() => 0),
+                this.getProperty('pause').catch(() => false),
+                this.getProperty('volume').catch(() => 100),
+                this.getProperty('loop-file').catch(() => 'no'),
+                this.getProperty('media-title').catch(() => undefined),
+            ]);
+            return {
+                title: title ? String(title) : undefined,
+                position: Number(position) || 0,
+                duration: Number(duration) || 0,
+                paused: Boolean(paused),
+                playing: true,
+                volume: Number(volume) || 100,
+                loop: String(loop),
+            };
+        }
+        catch {
+            return { position: 0, duration: 0, paused: false, playing: false, volume: 100, loop: 'no' };
+        }
+    }
+    async isRunning() {
+        try {
+            await this.getProperty('pid');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    getProperty(name) {
+        return this.sendCommand(['get_property', name]);
+    }
+    setProperty(name, value) {
+        return this.sendCommand(['set_property', name, value]);
+    }
+    sendCommand(command) {
+        return new Promise((resolve, reject) => {
+            const id = ++this.requestId;
+            const socket = net.createConnection(SOCKET_PATH);
+            let buffer = '';
+            socket.on('connect', () => {
+                const msg = JSON.stringify({ command, request_id: id }) + '\n';
+                socket.write(msg);
+            });
+            socket.on('data', (data) => {
+                buffer += data.toString();
+                const lines = buffer.split('\n');
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const parsed = JSON.parse(line);
+                        if (parsed.request_id === id) {
+                            socket.destroy();
+                            if (parsed.error && parsed.error !== 'success') {
+                                reject(new Error(parsed.error));
+                            }
+                            else {
+                                resolve(parsed.data);
+                            }
+                            return;
+                        }
+                    }
+                    catch {
+                        // Ignore unparseable lines (event messages, etc.)
+                    }
+                }
+            });
+            socket.on('error', (err) => {
+                reject(new Error(`mpv IPC connection failed: ${err.message}`));
+            });
+            setTimeout(() => {
+                socket.destroy();
+                reject(new Error('mpv IPC timeout'));
+            }, 3000);
+        });
+    }
+}
+export const mpvPlayer = new MpvPlayer();

package/dist/types/index.d.ts

@@ -0,0 +1,68 @@
+export interface ApiResponse<T> {
+    success: boolean;
+    data: T | null;
+    error: ApiError | null;
+}
+export interface ApiError {
+    code: string;
+    message: string;
+}
+export interface Artist {
+    id: string;
+    name: string;
+}
+export interface Album {
+    id: string;
+    name: string;
+    picUrl?: string;
+}
+export interface Track {
+    id: string;
+    name: string;
+    artists: Artist[];
+    album: Album;
+    duration: number;
+    uri: string;
+}
+export interface Playlist {
+    id: string;
+    name: string;
+    description?: string;
+    coverUrl?: string;
+    trackCount: number;
+    creator?: {
+        id: string;
+        name: string;
+    };
+    tracks?: Track[];
+}
+export type SearchType = 'track' | 'album' | 'playlist' | 'artist';
+export interface SearchResult {
+    tracks?: Track[];
+    albums?: Album[];
+    playlists?: Playlist[];
+    artists?: Artist[];
+    total: number;
+    offset: number;
+    limit: number;
+}
+export interface Lyric {
+    lrc?: string;
+    tlyric?: string;
+}
+export type Quality = 'standard' | 'higher' | 'exhigh' | 'lossless' | 'hires';
+export interface UserProfile {
+    id: string;
+    nickname: string;
+    avatarUrl?: string;
+}
+export interface CookieData {
+    MUSIC_U?: string;
+    [key: string]: string | undefined;
+}
+export declare const ExitCode: {
+    readonly SUCCESS: 0;
+    readonly GENERAL_ERROR: 1;
+    readonly AUTH_ERROR: 2;
+    readonly NETWORK_ERROR: 3;
+};

package/dist/types/index.js

@@ -0,0 +1,6 @@
+export const ExitCode = {
+    SUCCESS: 0,
+    GENERAL_ERROR: 1,
+    AUTH_ERROR: 2,
+    NETWORK_ERROR: 3,
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "neteasecli",
+  "version": "2.0.0",
+  "description": "Simple CLI for Netease Cloud Music",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "neteasecli": "./dist/index.js"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "format": "prettier --write src/",
+    "format:check": "prettier --check src/",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "netease",
+    "netease-cloud-music",
+    "ncm",
+    "music",
+    "music-cli",
+    "cli",
+    "terminal",
+    "mpv",
+    "streaming",
+    "player",
+    "163music",
+    "wangyiyun"
+  ],
+  "author": "wangwalk",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wangwalk/neteasecli.git"
+  },
+  "dependencies": {
+    "@steipete/sweet-cookie": "^0.1.0",
+    "axios": "^1.6.0",
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^20.10.0",
+    "eslint": "^9.39.2",
+    "eslint-config-prettier": "^10.1.8",
+    "prettier": "^3.8.1",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0",
+    "typescript-eslint": "^8.54.0"
+  }
+}