neteasecli 2.0.0

package/dist/cli/player.js

@@ -0,0 +1,155 @@
+import { Command } from 'commander';
+import { mpvPlayer } from '../player/mpv.js';
+import { output, outputError } from '../output/json.js';
+import { ExitCode } from '../types/index.js';
+function formatTime(seconds) {
+    const mins = Math.floor(seconds / 60);
+    const secs = Math.floor(seconds % 60);
+    return `${mins}:${secs.toString().padStart(2, '0')}`;
+}
+async function requireRunning() {
+    if (!(await mpvPlayer.isRunning())) {
+        outputError('PLAYER_ERROR', 'Nothing is playing');
+        process.exit(ExitCode.GENERAL_ERROR);
+    }
+}
+export function createPlayerCommand() {
+    const player = new Command('player').description('Playback control');
+    player
+        .command('status')
+        .description('Current playback status')
+        .action(async () => {
+        try {
+            const status = await mpvPlayer.getStatus();
+            if (!status.playing) {
+                output({ playing: false, message: 'Nothing is playing' });
+                return;
+            }
+            const repeat = status.loop !== 'no' && status.loop !== 'false';
+            output({
+                playing: true,
+                paused: status.paused,
+                title: status.title,
+                position: status.position,
+                duration: status.duration,
+                positionFormatted: formatTime(status.position),
+                durationFormatted: formatTime(status.duration),
+                volume: Math.round(status.volume),
+                repeat,
+                message: `${status.paused ? '⏸' : '▶'} ${status.title || 'Unknown'} ${formatTime(status.position)}/${formatTime(status.duration)} vol:${Math.round(status.volume)}%${repeat ? ' 🔁' : ''}`,
+            });
+        }
+        catch (error) {
+            outputError('PLAYER_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.GENERAL_ERROR);
+        }
+    });
+    player
+        .command('pause')
+        .description('Toggle pause/resume')
+        .action(async () => {
+        try {
+            await requireRunning();
+            await mpvPlayer.pause();
+            const status = await mpvPlayer.getStatus();
+            output({
+                paused: status.paused,
+                message: status.paused ? 'Paused' : 'Resumed',
+            });
+        }
+        catch (error) {
+            outputError('PLAYER_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.GENERAL_ERROR);
+        }
+    });
+    player
+        .command('stop')
+        .description('Stop playback')
+        .action(async () => {
+        try {
+            await mpvPlayer.stop();
+            output({ message: 'Stopped' });
+        }
+        catch (error) {
+            outputError('PLAYER_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.GENERAL_ERROR);
+        }
+    });
+    player
+        .command('seek <seconds>')
+        .description('Seek by relative seconds (e.g. 10, -10) or absolute with --absolute')
+        .option('--absolute', 'Seek to absolute position')
+        .action(async (seconds, opts) => {
+        try {
+            await requireRunning();
+            const secs = Number(seconds);
+            if (isNaN(secs)) {
+                outputError('PLAYER_ERROR', 'Invalid seconds value');
+                process.exit(ExitCode.GENERAL_ERROR);
+                return;
+            }
+            await mpvPlayer.seek(secs, opts.absolute ? 'absolute' : 'relative');
+            const status = await mpvPlayer.getStatus();
+            output({
+                position: status.position,
+                duration: status.duration,
+                positionFormatted: formatTime(status.position),
+                durationFormatted: formatTime(status.duration),
+                message: `Seeked to ${formatTime(status.position)}/${formatTime(status.duration)}`,
+            });
+        }
+        catch (error) {
+            outputError('PLAYER_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.GENERAL_ERROR);
+        }
+    });
+    player
+        .command('volume [level]')
+        .description('Get or set volume (0-150)')
+        .action(async (level) => {
+        try {
+            await requireRunning();
+            if (level !== undefined) {
+                const vol = Number(level);
+                if (isNaN(vol)) {
+                    outputError('PLAYER_ERROR', 'Invalid volume value');
+                    process.exit(ExitCode.GENERAL_ERROR);
+                    return;
+                }
+                await mpvPlayer.setVolume(vol);
+                output({ volume: vol, message: `Volume: ${vol}%` });
+            }
+            else {
+                const vol = await mpvPlayer.getVolume();
+                output({ volume: vol, message: `Volume: ${Math.round(vol)}%` });
+            }
+        }
+        catch (error) {
+            outputError('PLAYER_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.GENERAL_ERROR);
+        }
+    });
+    player
+        .command('repeat [mode]')
+        .description('Toggle or set repeat mode (off/on)')
+        .action(async (mode) => {
+        try {
+            await requireRunning();
+            if (mode !== undefined) {
+                await mpvPlayer.setLoop(mode === 'on' ? 'inf' : 'no');
+                output({ repeat: mode === 'on', message: `Repeat: ${mode}` });
+            }
+            else {
+                const current = await mpvPlayer.getLoop();
+                const isOn = current !== 'no' && current !== 'false';
+                await mpvPlayer.setLoop(isOn ? 'no' : 'inf');
+                output({ repeat: !isOn, message: `Repeat: ${!isOn ? 'on' : 'off'}` });
+            }
+        }
+        catch (error) {
+            outputError('PLAYER_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.GENERAL_ERROR);
+        }
+    });
+    return player;
+}

package/dist/cli/playlist.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createPlaylistCommand(): Command;

package/dist/cli/playlist.js

@@ -0,0 +1,60 @@
+import { Command } from 'commander';
+import { getUserPlaylists, getPlaylistDetail } from '../api/playlist.js';
+import { output, outputError } from '../output/json.js';
+import { ExitCode } from '../types/index.js';
+export function createPlaylistCommand() {
+    const playlist = new Command('playlist').description('Playlists');
+    playlist
+        .command('list')
+        .description('List my playlists')
+        .action(async () => {
+        try {
+            const playlists = await getUserPlaylists();
+            output({
+                playlists: playlists.map((p) => ({
+                    id: p.id,
+                    name: p.name,
+                    trackCount: p.trackCount,
+                    creator: p.creator?.name,
+                })),
+                total: playlists.length,
+            });
+        }
+        catch (error) {
+            outputError('PLAYLIST_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.NETWORK_ERROR);
+        }
+    });
+    playlist
+        .command('detail')
+        .description('Playlist details')
+        .argument('<id>', 'Playlist ID')
+        .option('-l, --limit <number>', 'Track count limit', '50')
+        .action(async (id, options) => {
+        try {
+            const detail = await getPlaylistDetail(id);
+            const limit = parseInt(options.limit);
+            output({
+                id: detail.id,
+                name: detail.name,
+                description: detail.description,
+                coverUrl: detail.coverUrl,
+                trackCount: detail.trackCount,
+                creator: detail.creator,
+                tracks: detail.tracks?.slice(0, limit).map((t) => ({
+                    id: t.id,
+                    name: t.name,
+                    artist: t.artists.map((a) => a.name).join(', '),
+                    album: t.album.name,
+                    duration: t.duration,
+                    uri: t.uri,
+                })),
+            });
+        }
+        catch (error) {
+            outputError('PLAYLIST_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.NETWORK_ERROR);
+        }
+    });
+    return playlist;
+}

package/dist/cli/search.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createSearchCommand(): Command;

package/dist/cli/search.js

@@ -0,0 +1,29 @@
+import { Command } from 'commander';
+import { search } from '../api/search.js';
+import { output, outputError } from '../output/json.js';
+import { ExitCode } from '../types/index.js';
+export function createSearchCommand() {
+    const searchCmd = new Command('search').description('Search music');
+    const createSubCommand = (type, description) => {
+        return new Command(type)
+            .description(description)
+            .argument('<keyword>', 'Search keyword')
+            .option('-l, --limit <number>', 'Result count', '20')
+            .option('-o, --offset <number>', 'Offset', '0')
+            .action(async (keyword, options) => {
+            try {
+                const result = await search(keyword, type, parseInt(options.limit), parseInt(options.offset));
+                output(result);
+            }
+            catch (error) {
+                outputError('SEARCH_ERROR', error instanceof Error ? error.message : 'Search failed');
+                process.exit(ExitCode.NETWORK_ERROR);
+            }
+        });
+    };
+    searchCmd.addCommand(createSubCommand('track', 'Search tracks'));
+    searchCmd.addCommand(createSubCommand('album', 'Search albums'));
+    searchCmd.addCommand(createSubCommand('playlist', 'Search playlists'));
+    searchCmd.addCommand(createSubCommand('artist', 'Search artists'));
+    return searchCmd;
+}

package/dist/cli/track.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createTrackCommand(): Command;

package/dist/cli/track.js

@@ -0,0 +1,119 @@
+import { Command } from 'commander';
+import { getTrackDetail, getTrackUrl, getLyric, downloadTrack } from '../api/track.js';
+import { mpvPlayer } from '../player/mpv.js';
+import { output, outputError } from '../output/json.js';
+import { ExitCode } from '../types/index.js';
+export function createTrackCommand() {
+    const track = new Command('track').description('Track info');
+    track
+        .command('detail')
+        .description('Track details')
+        .argument('<id>', 'Track ID')
+        .action(async (id) => {
+        try {
+            const detail = await getTrackDetail(id);
+            output({
+                id: detail.id,
+                name: detail.name,
+                artists: detail.artists,
+                album: detail.album,
+                duration: detail.duration,
+                durationFormatted: formatDuration(detail.duration),
+                uri: detail.uri,
+            });
+        }
+        catch (error) {
+            outputError('TRACK_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.NETWORK_ERROR);
+        }
+    });
+    track
+        .command('url')
+        .description('Get streaming URL')
+        .argument('<id>', 'Track ID')
+        .option('-q, --quality <level>', 'Quality: standard/higher/exhigh/lossless/hires', 'exhigh')
+        .action(async (id, options) => {
+        try {
+            const url = await getTrackUrl(id, options.quality);
+            output({ id, url, quality: options.quality });
+        }
+        catch (error) {
+            outputError('TRACK_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.NETWORK_ERROR);
+        }
+    });
+    track
+        .command('lyric')
+        .description('Get lyrics')
+        .argument('<id>', 'Track ID')
+        .action(async (id) => {
+        try {
+            const lyric = await getLyric(id);
+            output({
+                id,
+                lrc: lyric.lrc,
+                tlyric: lyric.tlyric,
+                hasLyric: !!lyric.lrc,
+                hasTranslation: !!lyric.tlyric,
+            });
+        }
+        catch (error) {
+            outputError('TRACK_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.NETWORK_ERROR);
+        }
+    });
+    track
+        .command('download')
+        .description('Download track')
+        .argument('<id>', 'Track ID')
+        .option('-q, --quality <level>', 'Quality: standard/higher/exhigh/lossless/hires', 'exhigh')
+        .option('-o, --output <path>', 'Output file path')
+        .action(async (id, options) => {
+        try {
+            const result = await downloadTrack(id, options.quality, options.output);
+            output({
+                id,
+                path: result.path,
+                size: result.size,
+                quality: options.quality,
+            });
+        }
+        catch (error) {
+            outputError('TRACK_ERROR', error instanceof Error ? error.message : 'Download failed');
+            process.exit(ExitCode.NETWORK_ERROR);
+        }
+    });
+    track
+        .command('play')
+        .description('Play track via mpv')
+        .argument('<id>', 'Track ID')
+        .option('-q, --quality <level>', 'Quality: standard/higher/exhigh/lossless/hires', 'exhigh')
+        .action(async (id, options) => {
+        try {
+            const [url, detail] = await Promise.all([
+                getTrackUrl(id, options.quality),
+                getTrackDetail(id),
+            ]);
+            const title = `${detail.name} - ${detail.artists.map((a) => a.name).join('/')}`;
+            await mpvPlayer.play(url, title);
+            output({
+                id,
+                name: detail.name,
+                artists: detail.artists,
+                quality: options.quality,
+                message: `Now playing: ${title}`,
+            });
+        }
+        catch (error) {
+            outputError('PLAYER_ERROR', error instanceof Error ? error.message : 'Playback failed');
+            process.exit(ExitCode.GENERAL_ERROR);
+        }
+    });
+    return track;
+}
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${minutes}:${secs.toString().padStart(2, '0')}`;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { createProgram } from './cli/index.js';
+const program = createProgram();
+try {
+    await program.parseAsync();
+}
+catch (error) {
+    if (error instanceof Error) {
+        console.error(JSON.stringify({
+            success: false,
+            error: {
+                code: 'CLI_ERROR',
+                message: error.message,
+            },
+        }, null, 2));
+    }
+    process.exit(1);
+}

package/dist/output/color.d.ts

@@ -0,0 +1,7 @@
+export declare function setNoColor(v: boolean): void;
+export declare const bold: (t: string) => string;
+export declare const dim: (t: string) => string;
+export declare const green: (t: string) => string;
+export declare const red: (t: string) => string;
+export declare const yellow: (t: string) => string;
+export declare const cyan: (t: string) => string;

package/dist/output/color.js

@@ -0,0 +1,17 @@
+const envDisabled = !!process.env.NO_COLOR || process.env.TERM === 'dumb';
+let forceOff = false;
+export function setNoColor(v) {
+    forceOff = v;
+}
+function enabled() {
+    return !envDisabled && !forceOff && !!process.stdout.isTTY;
+}
+function wrap(code, text) {
+    return enabled() ? `\x1b[${code}m${text}\x1b[0m` : text;
+}
+export const bold = (t) => wrap(1, t);
+export const dim = (t) => wrap(2, t);
+export const green = (t) => wrap(32, t);
+export const red = (t) => wrap(31, t);
+export const yellow = (t) => wrap(33, t);
+export const cyan = (t) => wrap(36, t);

package/dist/output/json.d.ts

@@ -0,0 +1,7 @@
+type OutputMode = 'json' | 'plain' | 'human';
+export declare function setOutputMode(m: OutputMode): void;
+export declare function setPrettyPrint(value: boolean): void;
+export declare function setQuietMode(value: boolean): void;
+export declare function output<T>(data: T): void;
+export declare function outputError(code: string, message: string): void;
+export {};

package/dist/output/json.js

@@ -0,0 +1,201 @@
+import { bold, dim, green, red, cyan, yellow } from './color.js';
+let mode = process.stdout.isTTY ? 'human' : 'json';
+let prettyPrint = false;
+let quietMode = false;
+export function setOutputMode(m) {
+    mode = m;
+}
+export function setPrettyPrint(value) {
+    prettyPrint = value;
+}
+export function setQuietMode(value) {
+    quietMode = value;
+}
+export function output(data) {
+    if (quietMode)
+        return;
+    switch (mode) {
+        case 'json':
+            outputJson(data);
+            break;
+        case 'plain':
+            outputPlain(data);
+            break;
+        case 'human':
+            outputHuman(data);
+            break;
+    }
+}
+export function outputError(code, message) {
+    if (quietMode)
+        return;
+    switch (mode) {
+        case 'json': {
+            const response = {
+                success: false,
+                data: null,
+                error: { code, message },
+            };
+            console.log(prettyPrint ? JSON.stringify(response, null, 2) : JSON.stringify(response));
+            break;
+        }
+        case 'plain':
+            console.log(`error\t${code}\t${message}`);
+            break;
+        case 'human':
+            console.log(`${red('✗')} ${bold(code)}: ${message}`);
+            break;
+    }
+}
+// --- JSON mode ---
+function outputJson(data) {
+    const response = { success: true, data, error: null };
+    console.log(prettyPrint ? JSON.stringify(response, null, 2) : JSON.stringify(response));
+}
+// --- Plain mode ---
+function outputPlain(data) {
+    const d = data;
+    if (d.tracks && Array.isArray(d.tracks)) {
+        for (const t of d.tracks) {
+            console.log([t.id, t.name, t.artist || formatArtists(t.artists), t.album, t.uri].join('\t'));
+        }
+        return;
+    }
+    if (d.playlists && Array.isArray(d.playlists)) {
+        for (const p of d.playlists) {
+            console.log([p.id, p.name, p.trackCount, p.creator].join('\t'));
+        }
+        return;
+    }
+    if (d.lrc !== undefined) {
+        if (d.lrc)
+            console.log(String(d.lrc));
+        return;
+    }
+    if (d.url !== undefined) {
+        console.log(String(d.url));
+        return;
+    }
+    if (d.message !== undefined) {
+        console.log(String(d.message));
+        return;
+    }
+    // Fallback: key=value
+    for (const [k, v] of Object.entries(d)) {
+        if (v !== undefined && v !== null && typeof v !== 'object') {
+            console.log(`${k}\t${v}`);
+        }
+    }
+}
+// --- Human mode ---
+function outputHuman(data) {
+    const d = data;
+    // Track list (search results, library, playlist detail)
+    if (d.tracks && Array.isArray(d.tracks)) {
+        const tracks = d.tracks;
+        for (let i = 0; i < tracks.length; i++) {
+            const t = tracks[i];
+            const artist = t.artist || formatArtists(t.artists);
+            const dur = t.duration ? `  ${dim(formatDuration(Number(t.duration)))}` : '';
+            console.log(`  ${dim(String(i + 1).padStart(2, ' '))}  ${bold(String(t.name))} ${dim('-')} ${cyan(String(artist))}${dur}`);
+        }
+        const total = d.total !== undefined ? Number(d.total) : tracks.length;
+        const showing = d.showing !== undefined ? Number(d.showing) : tracks.length;
+        if (total > showing) {
+            console.log(dim(`\n  ${showing} of ${total} tracks`));
+        }
+        return;
+    }
+    // Playlist list
+    if (d.playlists && Array.isArray(d.playlists)) {
+        const pls = d.playlists;
+        for (let i = 0; i < pls.length; i++) {
+            const p = pls[i];
+            console.log(`  ${dim(String(i + 1).padStart(2, ' '))}  ${bold(String(p.name))} ${dim(`(${p.trackCount} tracks)`)}`);
+        }
+        return;
+    }
+    // Lyrics
+    if (d.lrc !== undefined) {
+        if (d.lrc) {
+            console.log(String(d.lrc));
+        }
+        else {
+            console.log(dim('No lyrics available'));
+        }
+        return;
+    }
+    // Single track detail
+    if (d.artists && Array.isArray(d.artists) && d.album && d.duration) {
+        console.log(`  ${bold(String(d.name))}`);
+        console.log(`  ${dim('Artist:')}  ${cyan(formatArtists(d.artists))}`);
+        const album = d.album;
+        console.log(`  ${dim('Album:')}   ${String(album.name)}`);
+        console.log(`  ${dim('Duration:')} ${d.durationFormatted || formatDuration(Number(d.duration))}`);
+        if (d.uri)
+            console.log(`  ${dim('URI:')}      ${String(d.uri)}`);
+        return;
+    }
+    // URL result
+    if (d.url !== undefined && d.quality !== undefined) {
+        console.log(`  ${dim('URL:')} ${String(d.url)}`);
+        console.log(`  ${dim('Quality:')} ${String(d.quality)}`);
+        return;
+    }
+    // Auth check result
+    if (d.credentials !== undefined && typeof d.credentials === 'object') {
+        const creds = d.credentials;
+        const warnings = d.warnings || [];
+        const profile = d.profile ? String(d.profile) : 'default';
+        console.log(`${bold('Credential check')} ${dim(`(profile: ${profile})`)}`);
+        console.log(dim('─'.repeat(40)));
+        for (const [name, found] of Object.entries(creds)) {
+            const icon = found ? green('✓') : red('✗');
+            const status = found ? 'found' : 'not found';
+            console.log(`${icon} ${bold(name)}: ${found ? green(status) : red(status)}`);
+        }
+        if (d.valid && d.nickname) {
+            console.log(`${green('✓')} ${bold('session')}: ${green('valid')} ${dim(`(${d.nickname})`)}`);
+        }
+        else if (creds.MUSIC_U) {
+            console.log(`${red('✗')} ${bold('session')}: ${red('expired or invalid')}`);
+        }
+        if (warnings.length > 0) {
+            console.log(`\n${yellow('⚠')} ${bold('Warnings:')}`);
+            for (const w of warnings) {
+                console.log(`   ${dim('-')} ${w}`);
+            }
+        }
+        if (!d.valid) {
+            console.log(`\n${red('✗')} Missing credentials. Options:`);
+            console.log(`   1. Login to ${cyan('music.163.com')} in Chrome, Edge, Firefox, or Safari`);
+            console.log(`   2. Run ${cyan('neteasecli auth login')}`);
+            console.log(`   3. Use ${cyan('--profile <name>')} for a specific Chrome/Edge profile`);
+        }
+        return;
+    }
+    // Message-based output (auth, player, etc.)
+    if (d.message !== undefined) {
+        const icon = green('✓');
+        console.log(`${icon} ${String(d.message)}`);
+        return;
+    }
+    // Fallback
+    for (const [k, v] of Object.entries(d)) {
+        if (v !== undefined && v !== null && typeof v !== 'object') {
+            console.log(`  ${dim(k + ':')} ${v}`);
+        }
+    }
+}
+// --- Helpers ---
+function formatArtists(artists) {
+    if (!Array.isArray(artists))
+        return String(artists || '');
+    return artists.map((a) => a.name || a).join(', ');
+}
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return `${minutes}:${secs.toString().padStart(2, '0')}`;
+}

package/dist/output/logger.d.ts

@@ -0,0 +1,6 @@
+export declare function setVerbose(v: boolean): void;
+export declare function setDebug(v: boolean): void;
+export declare function isVerbose(): boolean;
+export declare function isDebug(): boolean;
+export declare function verbose(msg: string): void;
+export declare function debug(msg: string): void;

package/dist/output/logger.js

@@ -0,0 +1,25 @@
+import { dim, yellow } from './color.js';
+let verboseEnabled = false;
+let debugEnabled = false;
+export function setVerbose(v) {
+    verboseEnabled = v;
+}
+export function setDebug(v) {
+    debugEnabled = v;
+    if (v)
+        verboseEnabled = true;
+}
+export function isVerbose() {
+    return verboseEnabled;
+}
+export function isDebug() {
+    return debugEnabled;
+}
+export function verbose(msg) {
+    if (verboseEnabled)
+        process.stderr.write(dim(`[verbose] ${msg}`) + '\n');
+}
+export function debug(msg) {
+    if (debugEnabled)
+        process.stderr.write(yellow(`[debug] ${msg}`) + '\n');
+}