halbot 1994.1.8 → 1995.1.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "halbot",
   "description": "Just another AI powered Telegram bot, which is simple design, easy to use, extendable and fun.",
-  "version": "1994.1.8",
+  "version": "1995.1.3",
   "private": false,
   "homepage": "https://github.com/Leask/halbot",
   "type": "module",
@@ -31,13 +31,13 @@
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "@ffprobe-installer/ffprobe": "^2.1.2",
-    "@google/genai": "^1.31.0",
+    "@google-cloud/discoveryengine": "^2.5.2",
+    "@google/genai": "^1.33.0",
     "@mozilla/readability": "^0.6.0",
     "fluent-ffmpeg": "^2.1.3",
     "google-gax": "^5.0.6",
     "ioredis": "^5.8.2",
-    "js-tiktoken": "^1.0.21",
-    "jsdom": "^27.2.0",
+    "jsdom": "^27.3.0",
     "lorem-ipsum": "^2.0.8",
     "mime": "^4.1.0",
     "mysql2": "^3.15.3",
@@ -46,8 +46,8 @@
     "pg": "^8.16.3",
     "pgvector": "^0.2.1",
     "telegraf": "^4.16.3",
-    "tesseract.js": "^6.0.1",
-    "utilitas": "^2000.3.26",
+    "tesseract.js": "^7.0.0",
+    "utilitas": "^2001.1.77",
     "youtube-transcript": "^1.2.1"
   }
 }

package/pipeline/010_broca.mjs

@@ -0,0 +1,261 @@
+import { alan, bot, hal, uoid, utilitas } from '../index.mjs';
+
+const _name = 'Broca';
+const [PRIVATE_LIMIT, GROUP_LIMIT] = [60 / 60, 60 / 20].map(x => x * 1000);
+const log = (c, o) => utilitas.log(c, _name, { time: 1, ...o || {} });
+const getKey = s => s?.toLowerCase?.()?.startsWith?.('http') ? 'url' : 'source';
+const isMarkdownError = e => e?.description?.includes?.("can't parse entities");
+
+const [CALLBACK_LIMIT, parse_mode] = [30, bot.parse_mode];
+
+const KNOWN_UPDATE_TYPES = [
+    'callback_query', 'channel_post', 'edited_message', 'message',
+    'my_chat_member', // 'inline_query',
+];
+
+const getExtra = (ctx, options) => {
+    const resp = {
+        reply_parameters: { message_id: ctx._.messageId },
+        disable_notification: !!ctx._.done.length, ...options || {},
+    };
+    resp.reply_markup || (resp.reply_markup = {});
+    if (options?.buttons?.length) {
+        resp.reply_markup.inline_keyboard = options?.buttons.map(row =>
+            utilitas.ensureArray(row).map(button => {
+                if (button.url) {
+                    return { text: button.label, url: button.url };
+                } else if (button.text) {
+                    const id = uoid.fakeUuid(button.text);
+                    ctx._.session.callback.push({ id, ...button });
+                    return {
+                        text: button.label,
+                        callback_data: JSON.stringify({ callback: id }),
+                    };
+                } else {
+                    utilitas.throwError('Invalid button markup.');
+                }
+            })
+        );
+    } else if (options?.keyboards) {
+        if (options.keyboards.length) {
+            resp.reply_markup.keyboard = options?.keyboards.map(utilitas.ensureArray);
+        } else { resp.reply_markup.remove_keyboard = true; }
+    }
+    return resp;
+};
+
+const resp = async (ctx, text, md, extra) => {
+    // if (ctx._.type === 'inline_query') {
+    //     return await ctx.answerInlineQuery([{}, {}]);
+    // }
+    let resp;
+    if (md) {
+        try {
+            resp = await (extra?.reply_parameters?.message_id
+                ? ctx.replyWithMarkdown(text, { parse_mode, ...extra })
+                : ctx.sendMessage(text, { parse_mode, ...extra }));
+        } catch (err) { // utilitas.throwError('Error sending message.');
+            isMarkdownError(err) || log(err);
+            await ctx.timeout();
+        }
+    }
+    resp || (resp = await utilitas.ignoreErrFunc(
+        async () => await (extra?.reply_parameters?.message_id
+            ? ctx.reply(text, extra) : ctx.sendMessage(text, extra)
+        ), hal.logOptions
+    ));
+    resp && ctx._.done.push(resp);
+    return resp;
+};
+
+const replyWith = async (ctx, func, src, options) => ctx._.done.push(
+    await ctx[func](Array.isArray(src) ? src.map(x => ({
+        type: x.type || 'photo', media: { [getKey(x.src)]: x.src },
+    })) : { [getKey(src)]: src }, ctx.getExtra(options))
+);
+
+const edit = async (ctx, lastMsgId, text, md, extra) => {
+    let resp;
+    if (md) {
+        try {
+            resp = await ctx.telegram.editMessageText(
+                ctx._.chatId, lastMsgId, '', text, { parse_mode, ...extra }
+            );
+        } catch (err) { // utilitas.throwError('Error editing message.');
+            isMarkdownError(err) || log(err);
+            await ctx.timeout();
+        }
+    }
+    resp || (resp = await utilitas.ignoreErrFunc(async (
+    ) => await ctx.telegram.editMessageText(
+        ctx._.chatId, lastMsgId, '', text, extra
+    ), hal.logOptions));
+    resp && ctx._.done.push(resp);
+    return resp;
+};
+
+const sessionGet = async chatId => {
+    const session = await alan.getSession(chatId) || {};
+    session.callback || (session.callback = []);
+    session.config || (session.config = {});
+    return session;
+};
+
+const sessionSet = async (chatId, session) => {
+    while (session?.callback?.length > CALLBACK_LIMIT) {
+        session.callback.shift();
+    }
+    return await alan.setSession(chatId, session);
+};
+
+const ctxExt = ctx => {
+    ctx.timeout = async () => await utilitas.timeout(ctx._.limit);
+    ctx.collect = (content, type, options) => type ? ctx._.collected.push(
+        { type, content }
+    ) : (ctx._.text = [
+        (options?.refresh ? '' : ctx._.text) || '', content || ''
+    ].filter(x => x.length).join('\n\n'));
+    ctx.hello = str => {
+        str = str || ctx._.session?.config?.hello || hal._.hello;
+        ctx.collect(str, null, { refresh: true });
+        return str;
+    };
+    ctx.getExtra = (options) => getExtra(ctx, options);
+    ctx.resp = async (text, md, extra) => await resp(ctx, text, md, extra);
+    ctx.edit = async (lastMsgId, text, md, extra) =>
+        await edit(ctx, lastMsgId, text, md, extra);
+    ctx.ok = async (message, options) => {
+        let pages = bot.paging(message, options);
+        const extra = ctx.getExtra(options);
+        const [pageIds, pageMap] = [[], {}];
+        options?.pageBreak || ctx._.done.filter(x => x).map(x => {
+            pageMap[x?.message_id] || (pageIds.push(x?.message_id));
+            pageMap[x?.message_id] = x;
+        });
+        for (let i in pages) {
+            const lastPage = ~~i === pages.length - 1;
+            const shouldExtra = options?.lastMessageId || lastPage;
+            if (options?.onProgress && !options?.lastMessageId
+                && pageMap[pageIds[~~i]]?.text === pages[i]) { continue; }
+            if (options?.onProgress && !pageIds[~~i]) {                     // progress: new page, reply text
+                await ctx.resp(pages[i], false, extra);
+            } else if (options?.onProgress) {                               // progress: ongoing, edit text
+                await ctx.edit(
+                    pageIds[~~i], pages[i], false, shouldExtra ? extra : {}
+                );
+            } else if (options?.lastMessageId || pageIds[~~i]) {            // progress: final, edit markdown
+                await ctx.edit(
+                    options?.lastMessageId || pageIds[~~i],
+                    pages[i], true, shouldExtra ? extra : {}
+                );
+            } else {                                                        // never progress, reply markdown
+                await ctx.resp(pages[i], true, extra);
+            }
+            await ctx.timeout();
+        }
+        return ctx._.done;
+    };
+    ctx.err = async (m, opts) => {
+        log(m);
+        return await ctx.ok(`⚠️ ${m?.message || m} `, opts);
+    };
+    ctx.shouldReply = async text => {
+        const should = utilitas.insensitiveHas(hal._?.chatType, ctx._.chatType)
+            || ctx._.session?.config?.chatty;
+        text = utilitas.isSet(text, true) ? (text || '') : '';
+        if (!should || !text) { return should; }
+        return await ctx.ok(text);
+    };
+    ctx.finish = () => ctx._.done.unshift(null);
+    ctx.complete = async (options) => await ctx.ok(hal.CHECK, options);
+    ctx.json = async (obj, options) => await ctx.ok(hal.json(obj), options);
+    ctx.list = async (list, options) => await ctx.ok(hal.uList(list), options);
+    ctx.audio = async (s, o) => await replyWith(ctx, 'replyWithAudio', s, o);
+    ctx.image = async (s, o) => await replyWith(ctx, 'replyWithPhoto', s, o);
+    ctx.video = async (s, o) => await replyWith(ctx, 'replyWithVideo', s, o);
+    ctx.media = async (s, o) => await replyWith(ctx, 'replyWithMediaGroup', s, o);
+};
+
+const action = async (ctx, next) => {
+    // log event
+    const e = `Event: ${ctx.update.update_id} => ${JSON.stringify(ctx.update)} `;
+    process.stdout.write(`[${_name.toUpperCase()} ${new Date().toISOString()}] ${e} \n`);
+    log(e);
+    // init ctx methods
+    ctxExt(ctx);
+    // init ctx storage
+    ctx._ = { chatId: 0, collected: [], done: [], text: '' };
+    // get message body
+    for (let t of KNOWN_UPDATE_TYPES) {
+        if (ctx.update[t]) {
+            ctx._.message = ctx.update[ctx._.type = t];
+            break;
+        }
+    }
+    if (ctx._.type === 'callback_query') { ctx._.message = ctx._.message.message; }
+    // else if (ctx._.type === 'inline_query') { ctx._.message.chat = { id: ctx._.message.from.id, type: PRIVATE }; }
+    else if (ctx._.type === 'my_chat_member') {
+        log(
+            'Group member status changed: '
+            + ctx._.message.new_chat_member.user.id + ' => '
+            + ctx._.message.new_chat_member.status
+        );
+        if (ctx._.message.new_chat_member.user.id !== ctx.botInfo.id
+            || ctx._.message.new_chat_member.status === 'left') {
+            return ctx.finish();
+        } else { ctx.hello(); }
+    } else if (!ctx._.type) { return log(`Unsupported message type.`); }
+    // get chat metadata
+    ctx._.chatId = ctx._.message.chat.id;
+    ctx._.chatType = ctx._.message.chat.type;
+    ctx._.messageId = ctx._.message.message_id;
+    ctx._.message.text && ctx.collect(ctx._.message.text);
+    ctx._.message.caption && ctx.collect(ctx._.message.caption);
+    // get session
+    ctx._.session = await sessionGet(ctx._.chatId);
+    ctx._.limit = ctx.chatType === hal.PRIVATE ? PRIVATE_LIMIT : GROUP_LIMIT;
+    ctx._.entities = [
+        ...(ctx._.message.entities || []).map(e => ({ ...e, text: ctx._.message.text })),
+        ...(ctx._.message.caption_entities || []).map(e => ({ ...e, text: ctx._.message.caption })),
+        ...(ctx._.message.reply_to_message?.entities || []).filter(
+            x => x?.type !== hal.BOT_COMMAND
+        ).map(e => ({ ...e, text: ctx._.message.reply_to_message.text })),
+    ].map(e => ({
+        ...e, matched: e.text.substring(e.offset, e.offset + e.length),
+        ...e.type === 'text_link' ? { type: 'url', matched: e.url } : {},
+    }));
+    // should process
+    ctx._.chatType !== hal.PRIVATE && (ctx._.entities.some(e => {
+        let target;
+        switch (e.type) {
+            case hal.MENTION: target = e.matched.substring(1, e.length); break;
+            case hal.BOT_COMMAND: target = e.matched.split('@')[1]; break;
+        }
+        return target === ctx.botInfo.username;
+    }) || ctx._.message.reply_to_message?.from?.username === ctx.botInfo.username
+        || ctx._.type === 'callback_query')
+        && (ctx._.chatType = hal.MENTION);
+    ctx._.chatType === hal.GROUP && (
+        await ctx.telegram.getChatMembersCount(ctx._.chatId) === 2
+    ) && (ctx._.chatType = hal.PRIVATE);
+    (((ctx._.text || ctx._.message.voice || ctx._.message.poll
+        || ctx._.message.data || ctx._.message.document || ctx._.message.photo
+        || ctx._.message.sticker || ctx._.message.video_note
+        || ctx._.message.video || ctx._.message.audio || ctx._.message.location
+        || ctx._.message.venue || ctx._.message.contact
+        || ctx._.message.checklist) && ctx._.messageId)
+        || (ctx._.message.new_chat_member || ctx._.message.left_chat_member))
+        && await next();
+    // persistence
+    await sessionSet(ctx._.chatId, ctx._.session);
+    // fallback response and log
+    if (ctx._.done.length) { return; }
+    const errStr = '⚠️ ' + (ctx._.cmd?.cmd
+        ? `Command not found: /${ctx._.cmd.cmd}` : 'No suitable response.');
+    log(`INFO: ${errStr}`);
+    await ctx.shouldReply(errStr);
+};
+
+export const { name, run, priority, func } = {
+    name: _name, run: true, priority: 10, func: action,
+};

package/pipeline/020_cmd.mjs

@@ -0,0 +1,83 @@
+import { bot, hal, utilitas } from '../index.mjs';
+
+const _name = 'CMD';
+const COMMAND_REGEXP = /^\/([a-z0-9_]+)(@([a-z0-9_]*))?\ ?(.*)$/sig;
+const log = (c, o) => utilitas.log(c, _name, { time: 1, ...o || {} });
+
+// https://stackoverflow.com/questions/69924954/an-error-is-issued-when-opening-the-telebot-keyboard
+const keyboards = [[
+    { text: `/ai ${bot.BOT}` },
+    { text: '/help 🛟' },
+], [
+    { text: '/set --tts=🔊' },
+    { text: '/set --tts=🔇' },
+], [
+    { text: '/set --chatty=🐵' },
+    { text: '/set --chatty=🙊' },
+]];
+
+const action = async (ctx, next) => {
+    // reload functions
+    const _ok = ctx.ok;
+    // @TODO: this will case keyboard showup everytime
+    // ctx.ok = async (message, options) => await _ok(message, {
+    //     ...options || {},
+    //     ...options?.buttons ? {} : (options?.keyboards || { keyboards }),
+    // });
+    // handle callback query
+    if (ctx._.type === 'callback_query') {
+        const data = utilitas.parseJson(ctx.update.callback_query.data);
+        const cb = ctx._.session?.callback?.filter?.(x => x.id === data?.callback)?.[0];
+        if (cb?.text) {
+            log(`Callback: ${cb.text}`); // Avoid ctx._.text interference:
+            ctx.collect(cb.text, null, { refresh: true });
+        } else {
+            return await ctx.err(
+                `Command is invalid or expired: ${ctx._.message.data}`
+            );
+        }
+    }
+    // handle text command
+    for (let e of ctx._.entities || []) {
+        if (e.type !== hal.BOT_COMMAND) { continue; }
+        if (!COMMAND_REGEXP.test(e.matched)) { continue; }
+        const cmd = utilitas.trim(e.matched.replace(
+            COMMAND_REGEXP, '$1'
+        ), { case: 'LOW' });
+        ctx._.cmd = { cmd, args: e.text.substring(e.offset + e.length + 1) };
+        break;
+    }
+    for (let str of [ctx._.text || '', ctx._.message.caption || ''].map(utilitas.trim)) {
+        if (!ctx._.cmd && COMMAND_REGEXP.test(str)) {
+            ctx._.cmd = { // this will faild if command includes urls
+                cmd: str.replace(COMMAND_REGEXP, '$1').toLowerCase(),
+                args: str.replace(COMMAND_REGEXP, '$4'),
+            };
+            break;
+        }
+    }
+    // update last touched command
+    if (ctx._.cmd) {
+        log(`Command: ${JSON.stringify(ctx._.cmd)}`);
+        ctx._.session.cmds || (ctx._.session.cmds = {});
+        ctx._.session.cmds[ctx._.cmd.cmd]
+            = { args: ctx._.cmd.args, touchedAt: Date.now() };
+    }
+    // handle commands
+    switch (ctx.cmd?.cmd) {
+        case 'clearkb':
+            return await ctx.complete({ keyboards: [] });
+    }
+    // next middleware
+    await next();
+};
+
+export const { name, run, hidden, priority, func, help, cmds } = {
+    name: _name, run: true, hidden: true, priority: 20, func: action,
+    help: bot.lines([
+        '¶ Commands handler.',
+    ]),
+    cmds: {
+        clearkb: 'Clear keyboard: /clearkb',
+    },
+};

package/pipeline/030_echo.mjs

@@ -0,0 +1,70 @@
+import { bot, hal, utilitas } from '../index.mjs';
+
+let lorem;
+
+const action = async (ctx, next) => {
+    let resp, md = true;
+    switch (ctx._.cmd.cmd) {
+        case 'echo':
+            const carry = { ...ctx._ };
+            delete carry.session.messages;
+            resp = hal.json({ update: ctx.update, _: carry });
+            break;
+        case 'uptime':
+            resp = utilitas.uptime();
+            break;
+        case 'thethreelaws':
+            resp = bot.lines([
+                `Isaac Asimov's [Three Laws of Robotics](https://en.wikipedia.org/wiki/Three_Laws_of_Robotics):`,
+                hal.oList([
+                    'A robot may not injure a human being or, through inaction, allow a human being to come to harm.',
+                    'A robot must obey the orders given it by human beings except where such orders would conflict with the First Law.',
+                    'A robot must protect its own existence as long as such protection does not conflict with the First or Second Laws.',
+                ])
+            ]);
+            break;
+        case 'ultimateanswer':
+            resp = '[The Answer to the Ultimate Question of Life, The Universe, and Everything is `42`](https://en.wikipedia.org/wiki/Phrases_from_The_Hitchhiker%27s_Guide_to_the_Galaxy).';
+            break;
+        case 'lorem':
+            lorem || (lorem = new (await utilitas.need('lorem-ipsum')).LoremIpsum);
+            const ipsum = () => text += `\n\n${lorem.generateParagraphs(1)}`;
+            const [demoTitle, demoUrl] = [
+                'Lorem ipsum', 'https://en.wikipedia.org/wiki/Lorem_ipsum',
+            ];
+            let [text, extra] = [`[${demoTitle}](${demoUrl})`, {
+                buttons: [{ label: demoTitle, url: demoUrl }]
+            }];
+            await ctx.ok(bot.EMOJI_THINKING);
+            for (let i = 0; i < 2; i++) {
+                await ctx.timeout();
+                await ctx.ok(ipsum(), { ...extra, onProgress: true });
+            }
+            await ctx.timeout();
+            await ctx.ok(ipsum(), { ...extra, md });
+            // testing incomplete markdown reply {
+            // await ctx.ok('_8964', { md });
+            // }
+            // test pagebreak {
+            // await ctx.timeout();
+            // await ctx.ok(ipsum(), { md, pageBreak: true });
+            // }
+            return;
+    }
+    await ctx.ok(resp, { md });
+};
+
+export const { _NEED, name, hidden, priority, func, help, cmds } = {
+    _NEED: ['lorem-ipsum'],
+    name: 'Echo', hidden: true, priority: 30, func: action,
+    help: bot.lines([
+        '¶ Basic behaviors for debug only.',
+    ]),
+    cmds: {
+        thethreelaws: `Isaac Asimov's [Three Laws of Robotics](https://en.wikipedia.org/wiki/Three_Laws_of_Robotics)`,
+        ultimateanswer: '[The Answer to the Ultimate Question of Life, The Universe, and Everything](https://bit.ly/43wDhR3).',
+        echo: 'Show debug message.',
+        uptime: 'Show uptime of this bot.',
+        lorem: '[Lorem ipsum](https://en.wikipedia.org/wiki/Lorem_ipsum)',
+    },
+};

package/pipeline/040_help.mjs

@@ -0,0 +1,46 @@
+import { bot, hal, utilitas } from '../index.mjs';
+
+const lines2 = arr => bot.lines(arr, '\n\n');
+
+const action = async (ctx, next) => {
+    const help = hal._.info ? [hal._.info] : [];
+    for (let i in hal._.pipeline) {
+        if (hal._.pipeline[i].hidden) { continue; }
+        const _help = [];
+        if (hal._.pipeline[i].help) {
+            _help.push(hal._.pipeline[i].help);
+        }
+        const cmds = hal._.pipeline[i].cmds || {};
+        if (utilitas.countKeys(cmds)) {
+            _help.push(bot.lines([
+                '_🪄 Commands:_',
+                ...Object.keys(cmds).map(x => `- /${x}: ${cmds[x]}`),
+            ]));
+        }
+        if (utilitas.countKeys(hal._.pipeline[i].args)) {
+            _help.push(bot.lines([
+                '_⚙️ Options:_',
+                ...Object.keys(hal._.pipeline[i].args).map(x => {
+                    const _arg = hal._.pipeline[i].args[x];
+                    return `- \`${x}\`` + (_arg.short ? `(${_arg.short})` : '')
+                        + `, ${_arg.type}(${_arg.default ?? 'N/A'})`
+                        + (_arg.desc ? `: ${_arg.desc}` : '');
+                })
+            ]));
+        }
+        _help.length && help.push(bot.lines([`*${i.toUpperCase()}*`, ..._help]));
+    }
+    await ctx.ok(lines2(help), { md: true });
+};
+
+export const { name, priority, func, help, cmds } = {
+    name: 'Help', priority: 40, func: action,
+    help: bot.lines([
+        '¶ Basic syntax of this document:',
+        'Scheme for commands: /`COMMAND`: `DESCRIPTION`',
+        'Scheme for options: `OPTION`(`SHORT`), `TYPE`(`DEFAULT`): `DESCRIPTION`',
+    ]),
+    cmds: {
+        help: 'Show help message.',
+    },
+};

package/pipeline/050_auth.mjs

@@ -0,0 +1,30 @@
+import { hal, utilitas } from '../index.mjs';
+
+// https://stackoverflow.com/questions/50204633/allow-bot-to-access-telegram-group-messages
+const action = async (ctx, next) => {
+    if (!await ctx.shouldReply()) { return; }                                   // if chatType is not in whitelist, exit.
+    if (!hal._.private) { return await next(); }                            // if not private, go next.
+    if (utilitas.insensitiveHas(hal._.private, ctx._.chatId) || (           // auth by chatId
+        ctx._.message?.from?.id && utilitas.insensitiveHas(                     // auth by userId
+            hal._.private, ctx._.message?.from?.id
+        ))) {
+        return await next();
+    }
+    if (ctx._.chatType !== hal.PRIVATE && (                                     // 1 of the group admins is in whitelist
+        await ctx.telegram.getChatAdministrators(ctx._.chatId)
+    ).map(x => x.user.id).some(a => utilitas.insensitiveHas(hal._.private, a))) {
+        return await next();
+    }
+    if (hal._.homeGroup && utilitas.insensitiveHas([                        // auth by homeGroup
+        'creator', 'administrator', 'member' // 'left'
+    ], (await utilitas.ignoreErrFunc(async (
+    ) => await ctx.telegram.getChatMember(
+        hal._.homeGroup, ctx._.message?.from?.id
+    )))?.status)) { return await next(); }
+    if (hal._.auth && await hal._.auth(ctx)) { return await next(); }   // auth by custom function
+    await ctx.ok('😿 Sorry, I am not allowed to talk to strangers.');
+};
+
+export const { name, run, priority, func } = {
+    name: 'Auth', run: true, priority: 50, func: action,
+};

package/pipeline/060_config.mjs

@@ -0,0 +1,86 @@
+import { bot, hal, utilitas } from '../index.mjs';
+
+const sendConfig = async (ctx, obj, options) => await ctx.ok(
+    utilitas.prettyJson(obj, { code: true, md: true }), options
+);
+
+const ctxExt = ctx => {
+    ctx.sendConfig = async (obj, options) => await sendConfig(ctx, obj, options);
+};
+
+const action = async (ctx, next) => {
+    ctxExt(ctx);
+    let parsed = null;
+    switch (ctx._.cmd.cmd) {
+        case 'lang':
+            if (!ctx._.cmd.args) {
+                return await ctx.ok('Please specify a language.');
+            }
+            const _config = {
+                ...ctx._.session.config = {
+                    ...ctx._.session.config || {},
+                    ...ctx._.config = {
+                        lang: ctx._.cmd.args,
+                        hello: `Please reply in ${ctx._.cmd.args}. Hello!`,
+                    },
+                }
+            };
+            Object.keys(ctx._.config).map(x => _config[x] += ` ${hal.CHECK}`);
+            ctx._.result = hal.map(_config);
+            ctx.hello();
+            break;
+        case 'toggle':
+            parsed = {};
+            Object.keys(await hal.parseArgs(ctx._.cmd.args)).map(x =>
+                parsed[x] = !ctx._.session?.config?.[x]);
+        case 'set':
+            try {
+                const _config = {
+                    ...ctx._.session.config = {
+                        ...ctx._.session?.config || {},
+                        ...ctx._.config = parsed || await hal.parseArgs(ctx._.cmd.args, ctx),
+                    }
+                };
+                assert(utilitas.countKeys(ctx._.config), 'No option matched.');
+                Object.keys(ctx._.config).map(x => _config[x] += ` ${hal.CHECK}`);
+                return await ctx.sendConfig(_config);
+            } catch (err) {
+                return await ctx.err(err.message || err);
+            }
+        case 'reset':
+            ctx._.session.config = ctx._.config = {};
+            return await ctx.complete();
+    }
+    await next();
+};
+
+export const { name, priority, func, help, cmds, args } = {
+    name: 'Config', priority: 60, func: action,
+    help: bot.lines([
+        '¶ Configure the bot by UNIX/Linux CLI style.',
+        'Using [node:util.parseArgs](https://nodejs.org/api/util.html#utilparseargsconfig) to parse arguments.',
+        '¶ Set your default language.',
+        'Example: /lang Français',
+        '¶ When enabled, the bot will speak out the answer if available.',
+        'Example 1: /set --tts on',
+        'Example 2: /set --tts off',
+    ]),
+    cmds: {
+        lang: 'Set your default language: /lang `LANG`',
+        toggle: 'Toggle configurations. Only works for boolean values.',
+        set: 'Usage: /set --`OPTION` `VALUE` -`SHORT`',
+        reset: 'Reset configurations.',
+    },
+    args: {
+        chatty: {
+            type: 'string', short: 'c', default: hal.ON,
+            desc: `\`(${hal.BINARY_STRINGS.join(', ')})\` Enable/Disable chatty mode.`,
+            validate: utilitas.humanReadableBoolean,
+        },
+        tts: {
+            type: 'string', short: 't', default: hal.ON,
+            desc: `\`(${hal.BINARY_STRINGS.join(', ')})\` Enable/Disable TTS. Default \`${hal.ON}\` except in groups.`,
+            validate: utilitas.humanReadableBoolean,
+        },
+    },
+};