discord-home-cinema/main.js

import { exec } from 'node:child_process';
import {
    readFile,
    writeFile
} from 'node:fs/promises';

import { overrideConsole } from 'nodejs-better-console';
import Eris from 'eris';
import { Command, Argument } from 'commander';
import KeyEvent from 'keyevent.json' assert { type: 'json' };
import { M3uParser } from 'm3u-parser-generator';
import { parse as parseXspf } from 'xspf-js';
import outdent from 'outdent';
import AsciiTable from 'ascii-table';
import dayjs from 'dayjs';
import { parse } from 'shell-quote';

import {
    botToken,
    botWhitelist,
    adbIp,
    adbPort,
    localMediaRootPath
} from './config.js';

overrideConsole();

const
    eris = new Eris(
        botToken,
        { intents: ['directMessages'] }
    ),
    adb = command => new Promise((resolve, reject) => exec(
        `adb -s ${adbIp}:${adbPort} shell "${command.replaceAll('"', '\\"')}"`,
        (
            error,
            stdout,
            stderr
        ) => {
            if(error || stderr)
                reject(error || stderr);
            else
                resolve(stdout.replace(/\r/g, '').trim());
        }
    )),
    getConfig = async id => {
        try {
            return JSON.parse(await readFile(`./data/${id}.json`, 'utf8'));
        }
        catch {
            return {};
        }
    },
    setConfig = async (id, config) => await writeFile(`./data/${id}.json`, JSON.stringify(config)),
    parseMediaUrl = url => {
        const
            pathname = decodeURI(new URL(url).pathname),
            title = pathname
                .slice(pathname.lastIndexOf('/') + 1, pathname.lastIndexOf('.'))
                .replace(/[\s\-._()&+\[\],]/g, ' ')
                .replace(/\s+/g, ' ');
        return {
            url,
            title,
            keywords: title.toLowerCase().split(' ')
        };
    },
    handleCommand = async ({
        content,
        authorID,
        attachments
    }) => {
        content = `${content[0].toLowerCase()}${content.slice(1)}`;
        const program = new Command('');
        let response;
        program.exitOverride();
        program.configureOutput({
            writeOut: output => response = { output, isRaw: true },
            writeErr: output => response = { output, isRaw: true }
        });
        program
            .command('shell')
            .description('Execute arbitrary shell command')
            .argument('<command>', 'Arbitrary shell command')
            .action(async command => {
                response = {
                    output: await adb(command),
                    isRaw: true
                }
            });
        program
            .command('home')
            .alias('h')
            .description('Go to home')
            .action(() => adb(`input keyevent ${KeyEvent.KEYCODE_HOME}`));
        program
            .command('back')
            .alias('b')
            .description('Go back')
            .action(() => adb(`input keyevent ${KeyEvent.KEYCODE_BACK}`));
        program
            .command('p')
            .description('Play/pause media')
            .action(() => adb(`input keyevent ${KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE}`));
        program
            .command('play')
            .description('Play media')
            .action(() => adb(`input keyevent ${KeyEvent.KEYCODE_MEDIA_PLAY}`));
        program
            .command('pause')
            .description('Pause media')
            .action(() => adb(`input keyevent ${KeyEvent.KEYCODE_MEDIA_PAUSE}`));
        program
            .command('prev')
            .description('Previous media')
            .action(() => adb(`input keyevent ${KeyEvent.KEYCODE_MEDIA_PREVIOUS}`));
        program
            .command('next')
            .alias('n')
            .description('Next media')
            .action(() => adb(`input keyevent ${KeyEvent.KEYCODE_MEDIA_NEXT}`));
        program
            .command('type')
            .description('Type text')
            .argument('<text>', 'Text to type')
            .action(text => adb(`input text ${text}`));
        program
            .command('press')
            .description('Press key')
            .addArgument(
                new Argument('<key>', 'Key to press')
                    .choices(['tab', 'enter'])
            )
            .action(key => adb(`input keyevent ${{
                'tab': KeyEvent.KEYCODE_TAB,
                'enter': KeyEvent.KEYCODE_ENTER
            }[key]}`));
        program
            .command('spotify')
            .description('Launch Spotify')
            .action(() => adb('monkey -p com.spotify.music 1'));
        program
            .command('mpv')
            .description('Play media on MPV')
            .argument('<url>', 'Media URL')
            .action(url => adb(`am start -a android.intent.action.VIEW -d ${url} -t video/any is.xyz.mpv`));
        program
            .command('playlist')
            .alias('pl')
            .description('Manage playlists & play on MPV')
            .argument('[name]', 'Playlist name')
            .argument('[media]', 'Playlist media index/title/partial title')
            .action(async (name, media) => {
                const
                    config = await getConfig(authorID) || {},
                    newPlaylistUrl = attachments[0]?.url;
                let { playlists } = config;
                if(!playlists)
                    config.playlists = playlists = [];
                if(!name){
                    if(!playlists.length)
                        return response = { embed: { title: `❌ No existing playlist` } };
                    return response = {
                        embed: {
                            title: `ℹ️ Your playlists :`,
                            description: playlists.map(playlist => `- [${playlist.name}](${playlist.url})`).join('\n')
                        }
                    };
                }
                let playlist = playlists.find(playlist => playlist.name === name);
                if(newPlaylistUrl){
                    if(!/\.(m3u8?|xspf)$/i.test(new URL(newPlaylistUrl).pathname))
                        return response = { embed: { title: `❌ Invalid playlist` } };
                    response = { embed: { title: `✅ Playlist updated` } };
                    if(!playlist){
                        playlists.push(playlist = { name });
                        response = { embed: { title: `✅ Playlist created` } };
                    }
                    playlist.url = newPlaylistUrl;
                    return setConfig(authorID, config);
                }
                if(!playlist)
                    return response = { embed: { title: `❌ Playlist not found` } };
                const { pathname: playlistPathname } = new URL(playlist.url);
                let
                    rawPlaylistData = await (await fetch(playlist.url)).text(),
                    playlistItems;
                if(/\.m3u8?$/i.test(playlistPathname)){
                    if(!rawPlaylistData.startsWith('#EXTM3U'))
                        rawPlaylistData = `#EXTM3U\n${rawPlaylistData}`;
                    playlistItems = M3uParser.parse(rawPlaylistData).medias.map(item => parseMediaUrl(item['location']));
                }
                if(/\.xspf?$/i.test(playlistPathname))
                    playlistItems = parseXspf(rawPlaylistData)['playlist']['tracks'].map(item => parseMediaUrl(item['location']));
                if(!media)
                    return response = {
                        output: outdent `
                            📀 ${playlist.name}
                            ${playlistItems.map((item, index) => `${index + 1}. \`${item.title}\``).join('\n')}
                        `
                    };
                const
                    isIndex = /^\d+$/.test(media),
                    keywords = isIndex ? undefined : media.toLowerCase().split(' '),
                    matchingPlaylistItems = isIndex
                        ? [playlistItems[parseInt(media) - 1]]
                        : playlistItems.filter(item => keywords.every(keyword => item.title.toLowerCase().includes(keyword)));
                if(matchingPlaylistItems.length === 0)
                    return response = { embed: { title: `❌ Media not found` } };
                if(matchingPlaylistItems.length > 1)
                    return response = {
                        output: outdent `
                            🔎 Multiple media found :
                            ${matchingPlaylistItems.map(item => `${playlistItems.indexOf(item) + 1}\\. \`${item.title}\``).join('\n')}
                        `
                    };
                const [matchingPlaylistItem] = matchingPlaylistItems;
                await adb(`am start -a android.intent.action.VIEW -d ${matchingPlaylistItem.url} -t video/any is.xyz.mpv`);
                return response = { embed: { title: `▶️ \`${matchingPlaylistItem.title}\` (${playlistItems.indexOf(matchingPlaylistItem) + 1}/${playlistItems.length})` } };
            });
        program
            .command('playlist.rm')
            .alias('pl.rm')
            .description('Remove playlist')
            .argument('<name>', 'Playlist name')
            .action(async name => {
                const
                    config = await getConfig(authorID) || {},
                    { playlists } = config,
                    playlistIndex = playlists?.findIndex(playlist => playlist.name === name);
                if([undefined, -1].includes(playlistIndex))
                    return response = { embed: { title: `❌ No existing playlist by that name` } };
                playlists.splice(playlistIndex, 1);
                await setConfig(authorID, config);
                response = { embed: { title: `✅ Playlist removed` } };
            });
        program
            .command('local')
            .alias('l')
            .description('List & play local media')
            .argument('[media]', 'Media title/partial title')
            .action(async title => {
                const mediaList = (await adb(`find ${localMediaRootPath} -iname "*.mkv" -o -iname "*.mp4"`)).split('\n').map(path => parseMediaUrl(`file://${path}`));
                if(!title)
                    return response = {
                        output: outdent `
                            📂 Local media :
                            ${mediaList.map(item => `- \`${item.title}\``).join('\n')}
                        `
                    };
                const
                    keywords = title.toLowerCase().split(' '),
                    matchingMediaList = mediaList.filter(item => keywords.every(keyword => item.title.toLowerCase().includes(keyword)));
                if(matchingMediaList.length === 0)
                    return response = { embed: { title: `❌ Media not found` } };
                if(matchingMediaList.length > 1)
                    return response = {
                        output: outdent `
                            🔎 Multiple media found :
                            ${matchingMediaList.map(item => `- \`${item.title}\``).join('\n')}
                        `
                    };
                const [matchingMedia] = matchingMediaList;
                await adb(`am start -a android.intent.action.VIEW -n com.android.gallery3d/.app.MovieActivity -d "${matchingMedia.url}" -e MediaPlayerType 2`);
                return response = { embed: { title: `▶️ \`${matchingMedia.title}\`` } };
            });
        program
            .command('kiwi')
            .description('Launch Kiwi browser')
            .argument('[url]', 'Website URL')
            .action(url => adb(url
                ? `am start -a android.intent.action.VIEW -d ${url} -t text/plain com.kiwibrowser.browser`
                : 'monkey -p com.kiwibrowser.browser 1'
            ));
        program
            .command('notifications')
            .description('Show notification history')
            .action(async () => {
                const items = [];
                let item;
                for(let line of (await adb('dumpsys notification --noredact')).split('\n')){
                    line = line.trim();
                    if(line.startsWith('NotificationRecord('))
                        items.push(item = { app: line.slice(35).split(' ')[0] });
                    if(line.startsWith('android.title='))
                        item.title = line.slice(line.indexOf('(') + 1, -1);
                    if(line.startsWith('android.text='))
                        item.text = line.slice(line.indexOf('(') + 1, -1);
                    if(line.startsWith('mCreationTimeMs='))
                        item.date = parseInt(line.slice(16));
                }
                items.sort((a, b) => b.date - a.date);
                response = {
                    output: new AsciiTable()
                        .setHeading('App', 'Time', 'Content')
                        .addRowMatrix(items
                            .sort((a, b) => b.date - a.date)
                            .map(item => [
                                item.app,
                                dayjs(item.date).format('DD/MM HH:mm'),
                                `${item.title}${item.title.length + item.text.length < 50 ? ` · ${item.text}` : ''}`
                            ])
                        ).toString(),
                    isRaw: true
                };
            });
        try {
            await program.parseAsync(
                parse(content),
                { from: 'user' }
            );
        }
        catch(error){
            if(!error.code?.startsWith?.('commander.'))
                throw error;
        }
        return response;
    };

eris.on(
    'error',
    error => console.error(error)
);

eris.on(
    'messageCreate',
    async message => {
        const
            {
                guildID,
                author: { id: authorID },
                channel: { id: channelID },
                id: messageID,
                content,
                attachments
            } = message,
            reply = async (content, isCodeBlock) => {
                const lines = content.split('\n');
                let chunk = isCodeBlock ? '```\n' : '';
                for(let lineIndex = 0; lineIndex < lines.length; lineIndex++){
                    const
                        line = lines[lineIndex] + '\n',
                        canAddLine = chunk.length + line.length + (isCodeBlock ? 3 : 0) <= 2000;
                    if(canAddLine)
                        chunk += line;
                    if(!canAddLine || lineIndex === lines.length - 1){
                        if(isCodeBlock)
                            chunk += '```';
                        await eris.createMessage(
                            channelID,
                            {
                                content: chunk,
                                messageReference: { messageID }
                            }
                        );
                        chunk = isCodeBlock ? `\`\`\`\n${line}` : line;
                    }
                }
            };
        if(message.author.bot) return;
        if(
            guildID
            ||
            !botWhitelist.includes(authorID)
        ) return message.addReaction('❌');
        await message.addReaction('⏳');
        try {
            const {
                output,
                isRaw,
                embed
            } = await handleCommand({
                content,
                authorID,
                attachments
            }) || {};
            if(output)
                await reply(output, isRaw);
            if(embed)
                await eris.createMessage(
                    channelID,
                    {
                        embed,
                        messageReference: { messageID }
                    }
                );
            await message.addReaction('✅');
        }
        catch(error){
            console.error(error);
            await message.addReaction('❌');
        }
    }
);

(async () => {
    await Promise.all([
        eris.connect(),
        new Promise(resolve => eris.once('ready', resolve)),
        new Promise(resolve => exec(`adb connect ${adbIp}:${adbPort}`, resolve))
    ]);
    console.log('Ready');
})().catch(error => console.error(error));