init

#!/usr/bin/env python3

import configparser
import html
import logging
import os
from pathlib import Path

import path
import re
import shlex
import subprocess
import sys
import glob
import getpass
import asyncio
from nio import AsyncClient, ClientConfig, InviteEvent, RoomMessageText, SyncError
from slack import RTMClient
from slack.errors import SlackApiError

def is_ignored(username):
    try:
        with open('etc/ignore', 'r') as f:
            for line in f:
                if line.rstrip() == username:
                    return True
    except OSError:
        pass
    return False

def sanitize_path(path):
    return path.replace('/', '')

def commands(tokens):
    argv = []
    for token in tokens:
        if token.literal() == '|':
            yield argv
            argv = []
        else:
            argv.append(token)
    if argv:
        yield argv

def run(commandline, env):
    try:
        tokens = shlex.split(commandline)
    except ValueError as e:
        return (255, '', str(e))

    processes = []

    for i, argv in enumerate(commands(tokens)):
        log.info('argv:{}'.format(argv))

        if i > MAXPIPES:
            return (255, '', 'exceeded maximum number of pipes ({})'.format(MAXPIPES))

        if i == 0:
            stdin = subprocess.DEVNULL
        else:
            stdin = processes[i - 1].stdout

        redir_at = None
        for i, token in enumerate(reversed(argv)):
            if token.literal() == '>>':
                redir_at = i
                break

        if redir_at != None:
            j = len(argv) - redir_at - 1
            argv.pop(j)
            try:
                chan_path = path.chan_path(env['CHAN'], argv.pop(j))
                stdout = open(chan_path, 'a+')
            except IndexError:
                return (255, '', 'bad redirect')
            except OSError as e:
                return (e.errno, '', str(e))
        else:
            stdout = subprocess.PIPE

        if len(argv) > 0:
            bin_path = os.path.join('bin', sanitize_path(argv[0]))
        else:
            bin_path = ''

        if os.path.isfile(bin_path):
            argv[0] = bin_path
        else:

            argv.insert(0, 'bin/rand')

        try:
            processes.append(subprocess.Popen(argv,
                                              stdin=stdin,
                                              stdout=stdout,
                                              stderr=subprocess.PIPE,
                                              env=env))
        except PermissionError:
            pass
        except FileNotFoundError as e:
            return (e.errno, '', str(e))

        if stdout != subprocess.PIPE:
            stdout.close()

    try:
        (stdout, stderr) = processes[-1].communicate(timeout=TIMEOUT)
        # The pipeline status is the && of every process, i.e. pipefail is
        # always enabled. Don't bother preserving the exact status when there
        # is no second process.
        status = 0
        for process in processes:
            if process.wait():
                status = 1
    except subprocess.TimeoutExpired:
        processes[-1].kill()
        _ = processes[-1].communicate()
        return (255, '', 'timed out after {} seconds'.format(TIMEOUT))

    if stdout:
        stdout = stdout.decode('utf-8')
    else:
        stdout = ''

    return (status, stdout, stderr.decode('utf-8'))

def ensure_dir(d):
    try:
        os.mkdir(d)
    except OSError:
        pass

ROOT_DIR = Path("var/root")        # central place = dir that holds all the links

def ensure_alias(room_id: str, name: str) -> None:
    """
    Create or update a symlink in var/root/ that points to the given
    room's directory, making sure:
      • only one alias points to that room
      • the link’s target is *relative* to var/root/ so it works everywhere
    """
    if not name:
        return

    alias   = sanitize_path(name.lstrip("#"))                  # "#geeks" ➜ "geeks"
    link    = ROOT_DIR / alias                                 # var/root/geeks
    target  = Path(path.chan_path(room_id, "")).resolve()      # …/var/root/!pYoaw…

    try:
        # remove any old alias that already points to this room
        for entry in ROOT_DIR.iterdir():
            if entry.is_symlink() and entry.resolve() == target and entry != link:
                entry.unlink()

        # if the alias exists but points elsewhere, remove it
        if link.is_symlink() and link.resolve() != target:
            link.unlink()

        # store the target *relative* to var/root/  (../!pYoaw…)
        rel_target = os.path.relpath(target, ROOT_DIR)

        # create the new symlink (symlink() will raise if it still exists)
        link.symlink_to(rel_target)
    except OSError as e:
        print(f"ensure_alias: could not create {link} -> {rel_target}: {e}")

def handle_message(nick, channel, msg):
    if is_ignored(nick):
        return

    env = { 'NICK': nick, 'CHAN': channel, 'PATH': os.environ['PATH'] , 'PYTHONPATH': '.', 'HOME': '/root' }

    ensure_dir(path.chan_path(channel, ''))

    for f in glob.glob('lib/filter/*'):
        argv  = [f, msg]
        try:
            subprocess.Popen(argv, env=env).communicate()
        except PermissionError:
            pass

    if msg.startswith(LEADER):
        commandline = msg[len(LEADER):]
        status, stdout, stderr = run(commandline, env)
        with open('var/status', 'w') as f:
            f.write('{}\n'.format(status))
        log.info('command:{} status:{} stdout:{} stderr:{}'.format(repr(commandline), status, repr(stdout), repr(stderr)))
        stdout = stdout.rstrip()
        stderr = stderr.rstrip()
        response = stdout
        if stdout and stderr:
            response += "\n"
        response += stderr
        return response
    return None

# Matrix callbacks

async def room_message_text_callback(room, event):
    log.info("message:{}".format(event))

    nick = event.sender
    if is_ignored(nick):
        return
    channel = room.room_id
    ensure_alias(channel, getattr(room, 'display_name', None))
    msg = event.body

    response = handle_message(nick, channel, msg)

    if response:
        fmt = '<pre><code>{}</code></pre>' if '\n' in response else '<code>{}</code>'
        content = {
            "body": response,
            "msgtype": "m.text",
            "format": "org.matrix.custom.html",
            "formatted_body": fmt.format(html.escape(response)),
        }
        await client.room_send(room_id=room.room_id, message_type="m.room.message", content=content)

async def invite_callback(source, sender):
    log.info("invite:{}".format(source.room_id))
    await client.join(source.room_id)

async def login_and_sync_forever():
    await client.login(PASSWORD)
    # This extra sync is a hack to avoid seeing every event since our
    # (currently non-existent) saved sync token. We aren't even bothering with
    # saving a sync_token yet because it requires e2e (not sure why) and there
    # is no olm-dev package in our version of alpine (there is one in edge).
    await client.sync(30000)
    client.add_event_callback(room_message_text_callback, RoomMessageText)
    client.add_event_callback(invite_callback, InviteEvent)
    await client.sync_forever(30000)

# Slack callbacks

@RTMClient.run_on(event='message')
def run_on_message(**payload):
    try:
        data = payload['data']
        web_client = payload['web_client']
        if 'text' in data:
            user = data['user']
            channel = data['channel']
            text = html.unescape(data.get('text', []))
            thread_ts = data['ts']
            try:
                info = web_client.conversations_info(channel=channel)
                name = info['channel']['name']
            except Exception:
                name = None
            ensure_alias(channel, name)
            response = handle_message(user, channel, text)
            if response:
                web_client.chat_postMessage(
                    channel=channel,
                    text=response,
                    thread_ts=thread_ts
                )
    except SlackApiError as e:
        log.error(f"Got an error: {e.response['error']}")
    except Exception as e:
        log.error(f"{e}")

# Globals and other ugly, stateful stuff

log = logging.getLogger(__name__)
log.addHandler(logging.StreamHandler(sys.stderr))
log.setLevel(logging.DEBUG)

ensure_dir('var')
ensure_dir('var/root')

config = configparser.ConfigParser()
config.read('./etc/irsh.ini')
config = config['irsh']
KIND = config['kind']
LEADER = config['leader']
MAXPIPES = int(config['maxpipes'])
TIMEOUT = int(config['timeout'])
if KIND == 'matrix':
    URL = config['url']
    USERNAME = config['username']
    if 'password' in config:
        log.warning('using plaintext password from config file')
        PASSWORD = config['password']
    else:
        PASSWORD = getpass.getpass()
    client = AsyncClient(URL, USERNAME)
    asyncio.run(login_and_sync_forever())
elif KIND == 'slack':
    TOKEN=config['token']
    RTMClient(token=TOKEN).start()
else:
    log.exception('unknown kind in config file')