#--depends-on config #--depends-on permissions import re, string, traceback, typing from src import EventManager, ModuleManager, utils from . import outs COMMAND_METHOD = "command-method" COMMAND_METHODS = ["PRIVMSG", "NOTICE"] REGEX_ARG_NUMBER = re.compile(r"\$(\d+)(-?)") MESSAGE_TAGS_CAP = utils.irc.Capability("message-tags", "draft/message-tags-0.2") MSGID_TAG = utils.irc.MessageTag("msgid", "draft/msgid") NON_ALPHANUMERIC = [char for char in string.printable if not char.isalnum()] class BadContextException(Exception): def __init__(self, required_context): self.required_context = required_context Exception.__init__(self) SETTING_COMMANDMETHOD = utils.OptionsSetting(COMMAND_METHODS, COMMAND_METHOD, "Set the method used to respond to commands") @utils.export("channelset", utils.Setting("command-prefix", "Set the command prefix used in this channel", example="!")) @utils.export("serverset", utils.Setting("command-prefix", "Set the command prefix used on this server", example="!")) @utils.export("serverset", SETTING_COMMANDMETHOD) @utils.export("channelset", SETTING_COMMANDMETHOD) @utils.export("botset", SETTING_COMMANDMETHOD) @utils.export("channelset", utils.BoolSetting("hide-prefix", "Disable/enable hiding prefix in command reponses")) @utils.export("channelset", utils.BoolSetting("commands", "Disable/enable responding to commands in-channel")) @utils.export("channelset", utils.BoolSetting("prefixed-commands", "Disable/enable responding to prefixed commands in-channel")) class Module(ModuleManager.BaseModule): @utils.hook("new.user") @utils.hook("new.channel") def new(self, event): if "user" in event: target = event["user"] else: target = event["channel"] target.last_stdout = None target.last_stderr = None def has_command(self, command): return command.lower() in self.events.on("received").on( "command").get_children() def get_hooks(self, command): return self.events.on("received.command").on(command ).get_hooks() def is_highlight(self, server, s): if s and s[-1] in [":", ","]: return server.is_own_nickname(s[:-1]) def _get_aliases(self, server): return server.get_setting("command-aliases", {}) def _set_aliases(self, server, aliases): server.set_setting("command-aliases", aliases) def _alias_arg_replace(self, s, args_split): for match in REGEX_ARG_NUMBER.finditer(s): index = int(match.group(1)) continuous = match.group(2) == "-" if index >= len(args_split): raise IndexError("Unknown alias arg index") if continuous: replace = " ".join(args_split[index:]) else: replace = args_split[index] s = s.replace(match.group(0), replace) return s.split(" ") def _command_method(self, target, server): return target.get_setting(COMMAND_METHOD, server.get_setting(COMMAND_METHOD, self.bot.get_setting(COMMAND_METHOD, "PRIVMSG"))) def _find_command_hook(self, server, command, is_channel, args_split): if not self.has_command(command): aliases = self._get_aliases(server) if command.lower() in aliases: command, _, new_args = aliases[command.lower()].partition(" ") try: args_split = self._alias_arg_replace(new_args, args_split) except IndexError: return None, None, None hook = None channel_skip = False private_skip = False if self.has_command(command): for potential_hook in self.get_hooks(command): alias_of = self._get_alias_of(potential_hook) if alias_of: if self.has_command(alias_of): potential_hook = self.get_hooks(alias_of)[0] else: raise ValueError( "'%s' is an alias of unknown command '%s'" % (command.lower(), alias_of.lower())) if not is_channel and potential_hook.get_kwarg("channel_only", False): channel_skip = True continue if is_channel and potential_hook.get_kwarg("private_only", False): private_skip = True continue hook = potential_hook break if not hook and (private_skip or channel_skip): raise BadContextException("channel" if channel_skip else "private") return hook, command, args_split def _check(self, context, kwargs, requests=[]): event_hook = self.events.on(context).on("command") returns = [] if requests: for request, request_args in requests: returns.append(event_hook.on(request).call_for_result_unsafe( **kwargs, request_args=request_args)) else: returns = event_hook.call_unsafe(**kwargs) hard_fail = False force_success = False error = None for returned in returns: if returned: type, message = returned if type == utils.consts.PERMISSION_HARD_FAIL: error = message hard_fail = True break elif type == utils.consts.PERMISSION_FORCE_SUCCESS: force_success = True break elif type == utils.consts.PERMISSION_ERROR: error = returned if hard_fail: return False, error elif not force_success and error: return False, error else: return True, None def _check_assert(self, check_kwargs, check: typing.Union[utils.Check, utils.MultiCheck]): checks = check.to_multi() # both Check and MultiCheck has this func is_success, message = self._check("check", check_kwargs, checks.requests()) if not is_success: raise utils.EventError(message) def command(self, server, target, target_str, is_channel, user, command, args_split, tags, hook, **kwargs): message_tags = server.has_capability(MESSAGE_TAGS_CAP) expect_output = hook.get_kwarg("expect_output", True) module_name = self._get_prefix(hook) or "" if not module_name and hasattr(hook.function, "__self__"): module_name = hook.function.__self__._name send_tags = {} if message_tags: msgid = MSGID_TAG.get_value(tags) if msgid: send_tags["+draft/reply"] = msgid if expect_output: server.send(utils.irc.protocol.tagmsg(target_str, {"+draft/typing": "active"}), immediate=True) stdout = outs.StdOut(server, module_name, target, target_str, send_tags) stderr = outs.StdErr(server, module_name, target, target_str, send_tags) command_method = self._command_method(target, server) ret = False has_out = False if hook.get_kwarg("remove_empty", True): args_split = list(filter(None, args_split)) event_kwargs = {"hook": hook, "user": user, "server": server, "target": target, "is_channel": is_channel, "tags": tags, "args_split": args_split, "command": command, "args": " ".join(args_split), "stdout": stdout, "stderr": stderr} event_kwargs.update(kwargs) check_assert = lambda check: self._check_assert(event_kwargs, check) event_kwargs["check_assert"] = check_assert check_success, check_message = self._check("preprocess", event_kwargs) if not check_success: if check_message: stderr.write(check_message).send(command_method) return True new_event = self.events.on(hook.event_name).make_event(**event_kwargs) self.log.trace("calling command '%s': %s", [command, new_event.kwargs]) try: hook.call(new_event) except utils.EventError as e: stderr.write(str(e)).send(command_method) return True if not hook.get_kwarg("skip_out", False): has_out = stdout.has_text() or stderr.has_text() if has_out: command_method = self._command_method(target, server) stdout.send(command_method) stderr.send(command_method) target.last_stdout = stdout target.last_stderr = stderr ret = new_event.eaten if expect_output and message_tags and not has_out: server.send(utils.irc.protocol.tagmsg(target_str, {"+draft/typing": "done"}), immediate=True) return ret @utils.hook("preprocess.command") def _check_min_args(self, event): min_args = event["hook"].get_kwarg("min_args") if min_args and len(event["args_split"]) < min_args: usage = self._get_usage(event["hook"], event["command"], event["command_prefix"]) error = None if usage: error = "Not enough arguments, usage: %s" % usage else: error = "Not enough arguments (minimum: %d)" % min_args return utils.consts.PERMISSION_HARD_FAIL, error def _command_prefix(self, server, channel): return channel.get_setting("command-prefix", server.get_setting("command-prefix", "!")) @utils.hook("received.message.channel", priority=EventManager.PRIORITY_LOW) def channel_message(self, event): commands_enabled = event["channel"].get_setting("commands", True) if not commands_enabled: return command_prefix = self._command_prefix(event["server"], event["channel"]) command = None args_split = None if event["message_split"][0].startswith(command_prefix): if not event["channel"].get_setting("prefixed-commands",True): return command = event["message_split"][0].replace( command_prefix, "", 1).lower() args_split = event["message_split"][1:] elif len(event["message_split"]) > 1 and self.is_highlight( event["server"], event["message_split"][0]): command = event["message_split"][1].lower() args_split = event["message_split"][2:] if command: if event["action"]: return try: hook, command, args_split = self._find_command_hook( event["server"], command, True, args_split) except BadContextException: event["channel"].send_message( "%s: That command is not valid in a channel" % event["user"].nickname) return if hook: self.command(event["server"], event["channel"], event["target_str"], True, event["user"], command, args_split, event["tags"], hook, command_prefix=command_prefix) else: self.events.on("unknown.command").call(server=event["server"], target=event["channel"], user=event["user"], command=command, command_prefix=command_prefix, is_channel=True) else: regex_hooks = self.events.on("command.regex").get_hooks() for hook in regex_hooks: if event["action"] and hook.get_kwarg("ignore_action", True): continue pattern = hook.get_kwarg("pattern", None) if not pattern and hook.get_kwarg("pattern-url", None) == "1": pattern = utils.http.REGEX_URL if pattern: match = re.search(pattern, event["message"]) if match: command = hook.get_kwarg("command", "") res = self.command(event["server"], event["channel"], event["target_str"], True, event["user"], command, "", event["tags"], hook, match=match, message=event["message"], command_prefix="") if res: break @utils.hook("received.message.private", priority=EventManager.PRIORITY_LOW) def private_message(self, event): if event["message_split"] and not event["action"]: command = event["message_split"][0].lower() # this should help catch commands when people try to do prefixed # commands ('!help' rather than 'help') in PM command = command.lstrip("".join(NON_ALPHANUMERIC)) args_split = event["message_split"][1:] try: hook, command, args_split = self._find_command_hook( event["server"], command, False, args_split) except BadContextException: event["user"].send_message( "That command is not valid in a PM") return if hook: self.command(event["server"], event["user"], event["user"].nickname, False, event["user"], command, args_split, event["tags"], hook, command_prefix="") else: self.events.on("unknown.command").call(server=event["server"], target=event["user"], user=event["user"], command=command, command_prefix="", is_channel=False) def _get_usage(self, hook, command, command_prefix=""): command = "%s%s" % (command_prefix, command) usages = hook.get_kwargs("usage") if usages: return " | ".join( "%s %s" % (command, usage) for usage in usages) return None def _get_prefix(self, hook): return hook.get_kwarg("prefix", None) def _get_alias_of(self, hook): return hook.get_kwarg("alias_of", None) @utils.hook("received.command.more", skip_out=True) def more(self, event): """ :help: Show more output from the last command """ if event["target"].last_stdout and event["target"].last_stdout.has_text(): event["target"].last_stdout.send( self._command_method(event["target"], event["server"])) @utils.hook("send.stdout") def send_stdout(self, event): target = event["target"] stdout = outs.StdOut(event["server"], event["module_name"], target, event.get("target_str", target.name), {}) if event.get("hide_prefix", False): stdout.hide_prefix() stdout.write(event["message"]).send( self._command_method(event["target"], event["server"])) if stdout.has_text(): event["target"].last_stdout = stdout @utils.hook("send.stderr") def send_stderr(self, event): target = event["target"] stderr = outs.StdErr(event["server"], event["module_name"], target, event.get("target_str", target.name), {}) if event.get("hide_prefix", False): stderr.hide_prefix() stderr.write(event["message"]).send( self._command_method(event["target"], event["server"])) if stderr.has_text(): event["target"].last_stderr = stderr @utils.hook("received.command.alias", min_args=2) def add_alias(self, event): """ :help: Add a command alias :usage: :permission: command-alias """ alias = event["args_split"][0].lower() command = " ".join(event["args_split"][1:]) aliases = self._get_aliases(event["server"]) aliases[alias] = command self._set_aliases(event["server"], aliases) event["stdout"].write("Added '%s' alias" % alias) @utils.hook("received.command.removealias", min_args=1) def remove_alias(self, event): """ :help: Remove a command alias :usage: :permission: command-alias """ alias = event["args_split"][0].lower() aliases = self._get_aliases(event["server"]) if not alias in aliases: raise utils.EventError("No '%s' alias" % alias) del aliases[alias] self._set_aliases(event["server"], aliases) event["stdout"].write("Removed '%s' alias" % alias) @utils.hook("check.command.self") def check_command_self(self, event): if event["server"].irc_lower(event["request_args"][0] ) == event["user"].name: return utils.consts.PERMISSION_FORCE_SUCCESS, None else: return (utils.consts.PERMISSION_ERROR, "You do not have permission to do this") @utils.hook("check.command.is-channel") def check_command_is_channel(self, event): if event["is_channel"]: return utils.consts.PERMISSION_FORCE_SUCCESS, None else: return (utils.consts.PERMISSION_ERROR, "This command can only be used in-channel")