neteasecli 2.0.0

package/dist/api/track.js

@@ -0,0 +1,96 @@
+import * as os from 'os';
+import * as path from 'path';
+import { getApiClient } from './client.js';
+const qualityBrMap = {
+    standard: 128000,
+    higher: 192000,
+    exhigh: 320000,
+    lossless: 999000,
+    hires: 999000,
+};
+export async function getTrackDetail(id) {
+    const client = getApiClient();
+    const response = await client.request('/song/detail', {
+        c: JSON.stringify([{ id: Number(id) }]),
+        ids: `[${id}]`,
+    });
+    if (!response.songs || response.songs.length === 0) {
+        throw new Error(`Track not found: ${id}`);
+    }
+    const track = response.songs[0];
+    const artists = track.ar || track.artists || [];
+    const album = track.al || track.album || { id: 0, name: '' };
+    return {
+        id: String(track.id),
+        name: track.name,
+        artists: artists.map((a) => ({ id: String(a.id), name: a.name })),
+        album: {
+            id: String(album.id),
+            name: album.name,
+            picUrl: album.picUrl,
+        },
+        duration: track.dt || track.duration || 0,
+        uri: `netease:track:${track.id}`,
+    };
+}
+export async function getTrackUrl(id, quality = 'exhigh') {
+    const client = getApiClient();
+    const br = qualityBrMap[quality];
+    const response = await client.request('/song/enhance/player/url', {
+        ids: `[${id}]`,
+        br,
+    });
+    if (!response.data || response.data.length === 0) {
+        throw new Error(`Cannot get track URL: ${id}`);
+    }
+    const url = response.data[0].url;
+    if (!url) {
+        throw new Error('Track unavailable (no copyright or VIP required)');
+    }
+    return url;
+}
+export async function getLyric(id) {
+    const client = getApiClient();
+    const response = await client.request('/song/lyric', {
+        id,
+        lv: -1,
+        tv: -1,
+    });
+    return {
+        lrc: response.lrc?.lyric,
+        tlyric: response.tlyric?.lyric,
+    };
+}
+export async function downloadTrack(id, quality = 'exhigh', outputPath) {
+    const client = getApiClient();
+    const url = await getTrackUrl(id, quality);
+    const ext = url.includes('.flac') ? 'flac' : 'mp3';
+    const dest = outputPath || path.join(os.tmpdir(), `neteasecli-${id}.${ext}`);
+    await client.download(url, dest);
+    const { size } = await import('fs').then((fs) => fs.statSync(dest));
+    return { path: dest, size };
+}
+export async function getTrackDetails(ids) {
+    const client = getApiClient();
+    const c = JSON.stringify(ids.map((id) => ({ id: Number(id) })));
+    const response = await client.request('/song/detail', {
+        c,
+        ids: `[${ids.join(',')}]`,
+    });
+    return (response.songs || []).map((track) => {
+        const artists = track.ar || track.artists || [];
+        const album = track.al || track.album || { id: 0, name: '' };
+        return {
+            id: String(track.id),
+            name: track.name,
+            artists: artists.map((a) => ({ id: String(a.id), name: a.name })),
+            album: {
+                id: String(album.id),
+                name: album.name,
+                picUrl: album.picUrl,
+            },
+            duration: track.dt || track.duration || 0,
+            uri: `netease:track:${track.id}`,
+        };
+    });
+}

package/dist/api/user.d.ts

@@ -0,0 +1,5 @@
+import type { Track, UserProfile } from '../types/index.js';
+export declare function getUserProfile(): Promise<UserProfile>;
+export declare function getLikedTrackIds(): Promise<string[]>;
+export declare function likeTrack(id: string, like?: boolean): Promise<void>;
+export declare function getRecentTracks(limit?: number): Promise<Track[]>;

package/dist/api/user.js

@@ -0,0 +1,50 @@
+import { getApiClient } from './client.js';
+function transformTrack(track) {
+    const artists = track.ar || track.artists || [];
+    const album = track.al || track.album || { id: 0, name: '' };
+    return {
+        id: String(track.id),
+        name: track.name,
+        artists: artists.map((a) => ({ id: String(a.id), name: a.name })),
+        album: {
+            id: String(album.id),
+            name: album.name,
+            picUrl: album.picUrl,
+        },
+        duration: track.dt || track.duration || 0,
+        uri: `netease:track:${track.id}`,
+    };
+}
+export async function getUserProfile() {
+    const client = getApiClient();
+    const response = await client.request('/nuser/account/get');
+    return {
+        id: String(response.profile.userId),
+        nickname: response.profile.nickname,
+        avatarUrl: response.profile.avatarUrl,
+    };
+}
+export async function getLikedTrackIds() {
+    const client = getApiClient();
+    const userProfile = await getUserProfile();
+    const response = await client.request('/song/like/get', {
+        uid: userProfile.id,
+    });
+    return response.ids.map(String);
+}
+export async function likeTrack(id, like = true) {
+    const client = getApiClient();
+    await client.request('/like', {
+        trackId: id,
+        like,
+    });
+}
+export async function getRecentTracks(limit = 100) {
+    const client = getApiClient();
+    const response = await client.request('/play/record', {
+        uid: (await getUserProfile()).id,
+        type: 0,
+        limit,
+    });
+    return (response.allData || []).map((item) => transformTrack(item.song));
+}

package/dist/auth/manager.d.ts

@@ -0,0 +1,24 @@
+import type { CookieData } from '../types/index.js';
+export declare class AuthManager {
+    private cookies;
+    private cookieSource;
+    constructor();
+    importFromBrowser(profile?: string): Promise<void>;
+    checkAuth(): Promise<{
+        valid: boolean;
+        userId?: string;
+        nickname?: string;
+        error?: string;
+        credentials: {
+            MUSIC_U: boolean;
+        };
+        warnings: string[];
+    }>;
+    isAuthenticated(): boolean;
+    getCookies(): CookieData | null;
+    getCookieString(): string;
+    getSource(): string | undefined;
+    logout(): void;
+}
+export declare function getAuthManager(): AuthManager;
+export declare function resetAuthManager(): void;

package/dist/auth/manager.js

@@ -0,0 +1,108 @@
+import { saveCookies, loadCookies, clearCookies } from './storage.js';
+export class AuthManager {
+    cookies = null;
+    cookieSource;
+    constructor() {
+        this.cookies = loadCookies();
+    }
+    async importFromBrowser(profile) {
+        const { getCookies } = await import('@steipete/sweet-cookie');
+        const options = {
+            url: 'https://music.163.com/',
+            names: ['MUSIC_U'],
+        };
+        if (profile) {
+            options.chromeProfile = profile;
+        }
+        const { cookies, warnings } = await getCookies(options);
+        const cookieData = {};
+        let source;
+        for (const cookie of cookies) {
+            cookieData[cookie.name] = cookie.value;
+            if (!source && cookie.source?.browser) {
+                source = cookie.source.browser;
+            }
+        }
+        if (!cookieData.MUSIC_U) {
+            const parts = ['Could not find Netease login cookies.'];
+            if (warnings.length > 0) {
+                parts.push('', 'Warnings:');
+                for (const w of warnings) {
+                    parts.push(`  - ${w}`);
+                }
+            }
+            parts.push('', 'Options:', '  1. Login to music.163.com in Chrome, Edge, Firefox, or Safari', '  2. Run `neteasecli auth login`', '  3. Use --profile <name> for a specific Chrome profile');
+            throw new Error(parts.join('\n'));
+        }
+        if (warnings.length > 0) {
+            const { verbose } = await import('../output/logger.js');
+            for (const w of warnings) {
+                verbose(`Cookie import warning: ${w}`);
+            }
+        }
+        this.cookies = cookieData;
+        this.cookieSource = source;
+        saveCookies(cookieData);
+    }
+    async checkAuth() {
+        const credentials = {
+            MUSIC_U: !!this.cookies?.MUSIC_U,
+        };
+        const warnings = [];
+        if (!this.cookies) {
+            warnings.push('No session file found. Run `neteasecli auth login` to import cookies from your browser.');
+            return { valid: false, error: 'Not logged in', credentials, warnings };
+        }
+        if (!credentials.MUSIC_U) {
+            warnings.push('Missing MUSIC_U cookie — login session not found');
+            return { valid: false, error: 'Missing credentials', credentials, warnings };
+        }
+        try {
+            const { getUserProfile } = await import('../api/user.js');
+            const profile = await getUserProfile();
+            return {
+                valid: true,
+                userId: profile.id,
+                nickname: profile.nickname,
+                credentials,
+                warnings,
+            };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Session expired';
+            warnings.push(`Session validation failed: ${msg}`);
+            return { valid: false, error: msg, credentials, warnings };
+        }
+    }
+    isAuthenticated() {
+        return this.cookies !== null && !!this.cookies.MUSIC_U;
+    }
+    getCookies() {
+        return this.cookies;
+    }
+    getCookieString() {
+        if (!this.cookies)
+            return '';
+        return Object.entries(this.cookies)
+            .filter(([, v]) => v !== undefined)
+            .map(([k, v]) => `${k}=${v}`)
+            .join('; ');
+    }
+    getSource() {
+        return this.cookieSource;
+    }
+    logout() {
+        this.cookies = null;
+        clearCookies();
+    }
+}
+let authManagerInstance = null;
+export function getAuthManager() {
+    if (!authManagerInstance) {
+        authManagerInstance = new AuthManager();
+    }
+    return authManagerInstance;
+}
+export function resetAuthManager() {
+    authManagerInstance = null;
+}

package/dist/auth/storage.d.ts

@@ -0,0 +1,7 @@
+import type { CookieData } from '../types/index.js';
+export declare function setProfile(name: string): void;
+export declare function getProfile(): string;
+export declare function saveCookies(cookies: CookieData): void;
+export declare function loadCookies(): CookieData | null;
+export declare function clearCookies(): void;
+export declare function listProfiles(): string[];

package/dist/auth/storage.js

@@ -0,0 +1,73 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const BASE_CONFIG_DIR = path.join(os.homedir(), '.config', 'neteasecli');
+let currentProfile = 'default';
+export function setProfile(name) {
+    if (name !== currentProfile) {
+        currentProfile = name;
+        // Invalidate cached auth manager so it reloads cookies for new profile
+        import('../auth/manager.js').then((m) => m.resetAuthManager());
+    }
+}
+export function getProfile() {
+    return currentProfile;
+}
+function getProfileDir() {
+    return path.join(BASE_CONFIG_DIR, 'profiles', currentProfile);
+}
+function getSessionFile() {
+    return path.join(getProfileDir(), 'session.json');
+}
+function ensureProfileDir() {
+    const dir = getProfileDir();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+// Migrate old flat session.json to default profile
+function migrateIfNeeded() {
+    const oldFile = path.join(BASE_CONFIG_DIR, 'session.json');
+    const newFile = path.join(BASE_CONFIG_DIR, 'profiles', 'default', 'session.json');
+    if (fs.existsSync(oldFile) && !fs.existsSync(newFile)) {
+        const dir = path.dirname(newFile);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.renameSync(oldFile, newFile);
+    }
+}
+// Run migration on module load
+migrateIfNeeded();
+export function saveCookies(cookies) {
+    ensureProfileDir();
+    fs.writeFileSync(getSessionFile(), JSON.stringify(cookies, null, 2));
+}
+export function loadCookies() {
+    const file = getSessionFile();
+    if (!fs.existsSync(file)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(file, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function clearCookies() {
+    const file = getSessionFile();
+    if (fs.existsSync(file)) {
+        fs.unlinkSync(file);
+    }
+}
+export function listProfiles() {
+    const profilesDir = path.join(BASE_CONFIG_DIR, 'profiles');
+    if (!fs.existsSync(profilesDir))
+        return [];
+    return fs.readdirSync(profilesDir).filter((name) => {
+        const sessionFile = path.join(profilesDir, name, 'session.json');
+        return fs.existsSync(sessionFile);
+    });
+}

package/dist/cli/auth.d.ts

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

package/dist/cli/auth.js

@@ -0,0 +1,62 @@
+import { Command } from 'commander';
+import { getAuthManager } from '../auth/manager.js';
+import { output, outputError } from '../output/json.js';
+import { ExitCode } from '../types/index.js';
+import { getProfile } from '../auth/storage.js';
+export function createAuthCommand() {
+    const auth = new Command('auth').description('Authentication');
+    auth
+        .command('login')
+        .description('Import login cookies from browser (Chrome, Edge, Firefox, Safari)')
+        .option('--profile <name>', 'Chrome/Edge profile name')
+        .action(async (options) => {
+        const authManager = getAuthManager();
+        try {
+            await authManager.importFromBrowser(options.profile);
+            const source = authManager.getSource();
+            output({
+                message: `Login successful${source ? ` (via ${source})` : ''}`,
+                authenticated: true,
+                browser: source || 'unknown',
+            });
+        }
+        catch (error) {
+            outputError('AUTH_ERROR', error instanceof Error ? error.message : 'Login failed');
+            process.exit(ExitCode.AUTH_ERROR);
+        }
+    });
+    auth
+        .command('check')
+        .description('Check login status')
+        .action(async () => {
+        const authManager = getAuthManager();
+        try {
+            const result = await authManager.checkAuth();
+            output({
+                valid: result.valid,
+                userId: result.userId,
+                nickname: result.nickname,
+                profile: getProfile(),
+                credentials: result.credentials,
+                warnings: result.warnings,
+                error: result.error,
+                message: result.valid
+                    ? `Logged in: ${result.nickname} (${result.userId})`
+                    : result.error || 'Not logged in',
+            });
+        }
+        catch (error) {
+            outputError('AUTH_ERROR', error instanceof Error ? error.message : 'Check failed');
+            process.exit(ExitCode.AUTH_ERROR);
+        }
+    });
+    auth
+        .command('logout')
+        .description('Logout')
+        .action(() => {
+        const authManager = getAuthManager();
+        authManager.logout();
+        output({ message: 'Logged out', authenticated: false });
+    });
+    return auth;
+}

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -0,0 +1,57 @@
+import { Command } from 'commander';
+import { createAuthCommand } from './auth.js';
+import { createSearchCommand } from './search.js';
+import { createPlaylistCommand } from './playlist.js';
+import { createLibraryCommand } from './library.js';
+import { createTrackCommand } from './track.js';
+import { createPlayerCommand } from './player.js';
+import { setOutputMode, setPrettyPrint, setQuietMode } from '../output/json.js';
+import { setNoColor } from '../output/color.js';
+import { setVerbose, setDebug } from '../output/logger.js';
+import { setProfile } from '../auth/storage.js';
+import { setRequestTimeout } from '../api/client.js';
+export function createProgram() {
+    const program = new Command();
+    program
+        .name('neteasecli')
+        .description('Netease Cloud Music CLI')
+        .version('2.0.0')
+        .option('--json', 'JSON output (default when piped)')
+        .option('--plain', 'Plain text output')
+        .option('--pretty', 'Pretty-print JSON')
+        .option('--quiet', 'Suppress output')
+        .option('--no-color', 'Disable colors')
+        .option('--profile <name>', 'Account profile', 'default')
+        .option('-v, --verbose', 'Verbose output')
+        .option('-d, --debug', 'Debug output (implies --verbose)')
+        .option('--timeout <seconds>', 'Request timeout in seconds', '30')
+        .hook('preAction', (thisCommand) => {
+        const opts = thisCommand.opts();
+        if (opts.profile && opts.profile !== 'default') {
+            setProfile(opts.profile);
+        }
+        if (opts.json)
+            setOutputMode('json');
+        if (opts.plain)
+            setOutputMode('plain');
+        if (opts.pretty)
+            setPrettyPrint(true);
+        if (opts.quiet)
+            setQuietMode(true);
+        if (!opts.color)
+            setNoColor(true);
+        if (opts.verbose)
+            setVerbose(true);
+        if (opts.debug)
+            setDebug(true);
+        if (opts.timeout)
+            setRequestTimeout(Number(opts.timeout) * 1000);
+    });
+    program.addCommand(createAuthCommand());
+    program.addCommand(createSearchCommand());
+    program.addCommand(createTrackCommand());
+    program.addCommand(createLibraryCommand());
+    program.addCommand(createPlaylistCommand());
+    program.addCommand(createPlayerCommand());
+    return program;
+}

package/dist/cli/library.d.ts

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

package/dist/cli/library.js

@@ -0,0 +1,92 @@
+import { Command } from 'commander';
+import { getLikedTrackIds, likeTrack, getRecentTracks } from '../api/user.js';
+import { getTrackDetails } from '../api/track.js';
+import { output, outputError } from '../output/json.js';
+import { ExitCode } from '../types/index.js';
+export function createLibraryCommand() {
+    const library = new Command('library').description('User library');
+    library
+        .command('liked')
+        .description('Liked tracks')
+        .option('-l, --limit <number>', 'Limit', '50')
+        .action(async (options) => {
+        try {
+            const ids = await getLikedTrackIds();
+            const limit = parseInt(options.limit);
+            const limitedIds = ids.slice(0, limit);
+            if (limitedIds.length === 0) {
+                output({ tracks: [], total: 0 });
+                return;
+            }
+            const tracks = await getTrackDetails(limitedIds);
+            output({
+                tracks: tracks.map((t) => ({
+                    id: t.id,
+                    name: t.name,
+                    artist: t.artists.map((a) => a.name).join(', '),
+                    album: t.album.name,
+                    uri: t.uri,
+                })),
+                total: ids.length,
+                showing: limitedIds.length,
+            });
+        }
+        catch (error) {
+            outputError('LIBRARY_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.NETWORK_ERROR);
+        }
+    });
+    library
+        .command('like')
+        .description('Like a track')
+        .argument('<track_id>', 'Track ID')
+        .action(async (trackId) => {
+        try {
+            await likeTrack(trackId, true);
+            output({ message: 'Liked', trackId });
+        }
+        catch (error) {
+            outputError('LIBRARY_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.NETWORK_ERROR);
+        }
+    });
+    library
+        .command('unlike')
+        .description('Unlike a track')
+        .argument('<track_id>', 'Track ID')
+        .action(async (trackId) => {
+        try {
+            await likeTrack(trackId, false);
+            output({ message: 'Unliked', trackId });
+        }
+        catch (error) {
+            outputError('LIBRARY_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.NETWORK_ERROR);
+        }
+    });
+    library
+        .command('recent')
+        .description('Recently played')
+        .option('-l, --limit <number>', 'Limit', '50')
+        .action(async (options) => {
+        try {
+            const limit = parseInt(options.limit);
+            const tracks = await getRecentTracks(limit);
+            output({
+                tracks: tracks.map((t) => ({
+                    id: t.id,
+                    name: t.name,
+                    artist: t.artists.map((a) => a.name).join(', '),
+                    album: t.album.name,
+                    uri: t.uri,
+                })),
+                total: tracks.length,
+            });
+        }
+        catch (error) {
+            outputError('LIBRARY_ERROR', error instanceof Error ? error.message : 'Failed');
+            process.exit(ExitCode.NETWORK_ERROR);
+        }
+    });
+    return library;
+}

package/dist/cli/player.d.ts

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