channelcmd.uc

import * as channel from "channel";
import * as router from "router";
import * as message from "message";
import * as textmessage from "textmessage";
import * as node from "node";

function getPublicChannels()
{
    const channels = [];
    const all = channel.getAllChannelNamekeys();
    for (let i = 0; i < length(all); i++) {
        const namekey = all[i];
        if (channel.isMeshtasticPreset(namekey) || channel.isMeshcorePreset(namekey) || channel.isAREDNPreset(namekey)) {
            push(channels, `<div class="cj">${split(namekey, " ")[0]}</div>`);
        }
        else if (ord(namekey) === 35 /* # */ || ord(namekey) === 37 /* % */ || channel.isAREDNOnly(namekey)) {
            push(channels, `<div class="cj" onclick='cmd("/channels join ${namekey}")'>${split(namekey, " ")[0]}</div>`);
        }
    }
    return sort(channels);
}

function getBridge()
{
    const services = platform.getTargetsByIdAndNamekey(null, null, true);
    for (let i = 0; i < length(services); i++) {
        const bridges = services[i].bridge;
        for (let j = 0; j < length(bridges); j++) {
            if (bridges[j].meship) {
                return services[i].id;
            }
        }
    }
    return null;
}

export function setup()
{
};

export function tick()
{
};

export function process(msg)
{
    if (msg.data?.command && node.toMe(msg)) {
        switch (msg.data.command.cmd) {
            case "get_public_channels":
            {
                router.queue(message.createMessage(msg.from, null,null, "command", {
                    id: msg.data.command.id,
                    cmd: "reply_public_channels",
                    channels: getPublicChannels(),
                }, {
                    hop_limit: 0
                }));
                break;
            }
            case "reply_public_channels":
            {
                const reply = [
                    "Public channels on world network:", "&nbsp;",
                    ...msg.data.command.channels
                ];
                event.queue({ cmd: "/reply", reply: reply, socket: msg.data.command.id });
            }
            default:
                break;
        }
    }
};

export function cmd(msg, reply)
{
    const cmd = msg.command;
    switch (cmd[0]) {
        case "help":
        {
            push(reply,
                "/channels [local] - list channels on local mesh",
                "/channels world - list channels on all meshes",
                "/channels join &lt;name&gt; [key] - join named channel (with key if necessary)",
                "/channels leave &lt;name&gt; - leave named channel"
            );
            break;
        }
        case "channels":
        {
            switch (cmd[1] ?? "local") {
                case "world":
                {
                    const bridge = getBridge();
                    if (bridge) {
                        router.queue(message.createMessage(bridge, null,null, "command", {
                            id: msg.socket,
                            cmd: "get_public_channels"
                        }, {
                            hop_limit: 0
                        }));
                        break;
                    }
                    // Fall through
                }
                case "local":
                {
                    push(reply,
                        "Public channels on local network:", "&nbsp;",
                        ...getPublicChannels()
                    );
                    break;
                }
                case "join":
                {
                    const name = cmd[2];
                    let key;
                    if (ord(name) === 35) { // #
                        key = b64enc(struct.pack("16B", ...crypto.sha256hash(name)));
                    }
                    else if (ord(name) === 37) { // %
                        key = "og==";
                    }
                    else {
                        key = cmd[3];
                    }
                    if (name && key) {
                        let join = true;
                        const namekey = `${name} ${key}`;
                        const newchannel = { namekey: namekey, max: 100, badge: true, images: false, telemetry: false, winlink: false };
                        const currchannels = map(channel.getAllLocalChannels(), c => {
                            const s = textmessage.state(c.namekey);
                            if (c.namekey === namekey) {
                                join = false;
                            }
                            return { namekey: c.namekey, max: s.max, badge: s.badge, images: s.images, telemetry: c.telemetry, winlink: s.winlink };
                        });
                        if (join) {
                            event.queue({ cmd: "newchannels", channels: [ ...currchannels, newchannel ] });
                            push(reply, `Joined channel ${name}`);
                        }
                    }
                    break;
                }
                case "leave":
                {
                    if (cmd[2]) {
                        const name = `${cmd[2]} `;
                        const currchannels = channel.getAllLocalChannels();
                        const newchannels = map(filter(currchannels, c => index(c.namekey, name) !== 0), c => {
                            const s = textmessage.state(c.namekey);
                            return { namekey: c.namekey, max: s.max, badge: s.badge, images: s.images, telemetry: c.telemetry, winlink: s.winlink };
                        });
                        if (length(currchannels) !== length(newchannels)) {
                            event.queue({ cmd: "newchannels", channels: newchannels });
                            push(reply, `Left channel ${name}`);
                        }
                    }
                    break;
                }
                default:
                    break;
            }
        }
        default:
            break;
    }
};