From f8fe1758ace98cc3fa8324780e4e7d2c2e70bbea Mon Sep 17 00:00:00 2001 From: Tibeuleu <> Date: Wed, 26 Mar 2025 17:38:04 +0100 Subject: [PATCH] add scripts to qutebrowser --- .config/qutebrowser/config.py | 7 +- .../qutebrowser/userscripts/qute-bitwarden | 295 ++++++++++++++++++ .../share/qutebrowser/userscripts/qute-getbib | 67 ++++ .../share/qutebrowser/userscripts/qute-scihub | 53 ++++ 4 files changed, 418 insertions(+), 4 deletions(-) create mode 100755 .local/share/qutebrowser/userscripts/qute-bitwarden create mode 100755 .local/share/qutebrowser/userscripts/qute-getbib create mode 100755 .local/share/qutebrowser/userscripts/qute-scihub diff --git a/.config/qutebrowser/config.py b/.config/qutebrowser/config.py index 2c1f55d..ff90a16 100644 --- a/.config/qutebrowser/config.py +++ b/.config/qutebrowser/config.py @@ -101,8 +101,6 @@ config.bind("dl", "hint links spawn wget -P Downloads {hint-url}") config.bind("dv", 'hint links spawn youtube-dl --add-metadata -i -o "~/Videos/[%(uploader)s] %(title)s.%(ext)s" {hint-url}') config.bind("da", 'hint links spawn youtube-dl --add-metadata -i -o "~/Music/%(title)s.%(ext)s" -x -f bestaudio/best {hint-url}') config.bind("dt", "hint links spawn wget -P .config/rtorrent/watch {hint-url}") -config.bind("pt", "open -t -- {clipboard}") -config.bind("pw", "open -w -- {clipboard}") config.bind("yc", "hint links yank") config.bind("yi", "hint images yank") config.bind("=", "zoom-in") @@ -112,7 +110,7 @@ config.bind("sb", "config-cycle statusbar.show never always") config.bind("zz", "history-clear") config.bind("l", "tab-pin") config.bind(".", "download-cancel") -# config.bind('pw', 'spawn --userscript ~/.local/bin/programs/qute-keepass -p ~/.local/profile-5.kdbx') +config.bind("pw", "spawn --userscript ~/.local/share/qutebrowser/userscripts/qute-bitwarden --totp --auto-lock 60 {url}") # ################################################################# # # COLORS @@ -511,7 +509,7 @@ c.content.javascript.can_open_tabs_automatically = False ## Enable JavaScript. ## This setting supports URL patterns. ## [Bool] -c.content.javascript.enabled = False +c.content.javascript.enabled = True # Enable JavaScript. # [Bool] @@ -1173,6 +1171,7 @@ c.url.searchengines = { "DEFAULT": "https://duckduckgo.com/?assist=off&q={}", "!aw": "https://wiki.archlinux.org/index.php/Special:Search?search={}", "!ads": "https://ui.adsabs.harvard.edu/search/q={}", + "!sci": "https://sci-hub.se/{}", "!g": "https://www.google.com/search?hl=en&q={}", "!w": "https://en.wikipedia.org/w/index.php?title=Special%3ASearch&search={}", "!y": "https://www.youtube.com/results?search_query={}&search=Search", diff --git a/.local/share/qutebrowser/userscripts/qute-bitwarden b/.local/share/qutebrowser/userscripts/qute-bitwarden new file mode 100755 index 0000000..91da726 --- /dev/null +++ b/.local/share/qutebrowser/userscripts/qute-bitwarden @@ -0,0 +1,295 @@ +#!/usr/bin/env python3 + +# SPDX-FileCopyrightText: Chris Braun (cryzed) +# +# SPDX-License-Identifier: GPL-3.0-or-later + +""" +Insert login information using Bitwarden CLI and a dmenu-compatible application +(e.g. dmenu, rofi -dmenu, ...). +""" + +USAGE = """The domain of the site has to be in the name of the Bitwarden entry, for example: "github.com/cryzed" or +"websites/github.com". The login information is inserted by emulating key events using qutebrowser's fake-key command in this manner: +[USERNAME][PASSWORD], which is compatible with almost all login forms. + +If enabled, with the `--totp` flag, it will also move the TOTP code to the +clipboard, much like the Firefox add-on. + +You must log into Bitwarden CLI using `bw login` prior to use of this script. +The session key will be stored using keyctl for the number of seconds passed to +the --auto-lock option. + +To use in qutebrowser, run: `spawn --userscript qute-bitwarden` +""" + +EPILOG = """Dependencies: tldextract (Python 3 module), pyperclip (optional +Python module, used for TOTP codes), Bitwarden CLI (1.7.4 is known to work +but older versions may well also work) + +WARNING: The login details are viewable as plaintext in qutebrowser's debug log +(qute://log) and might be shared if you decide to submit a crash report!""" + +import argparse +import enum +import functools +import os +import shlex +import subprocess +import sys +import json +import tldextract + +argument_parser = argparse.ArgumentParser( + description=__doc__, + usage=USAGE, + epilog=EPILOG, +) +argument_parser.add_argument("url", nargs="?", default=os.getenv("QUTE_URL")) +argument_parser.add_argument("--dmenu-invocation", "-d", default="dmenu -i -p Bitwarden", help="Invocation used to execute a dmenu-provider") +argument_parser.add_argument( + "--password-prompt-invocation", + "-p", + default='dmenupass "Master Password"', + help="Invocation used to prompt the user for their Bitwarden password", +) +argument_parser.add_argument("--no-insert-mode", "-n", dest="insert_mode", action="store_false", help="Don't automatically enter insert mode") +argument_parser.add_argument("--totp", "-t", action="store_true", help="Copy TOTP key to clipboard") +argument_parser.add_argument("--io-encoding", "-i", default="UTF-8", help="Encoding used to communicate with subprocesses") +argument_parser.add_argument("--merge-candidates", "-m", action="store_true", help="Merge pass candidates for fully-qualified and registered domain name") +argument_parser.add_argument("--auto-lock", type=int, default=900, help="Automatically lock the vault after this many seconds") +group = argument_parser.add_mutually_exclusive_group() +group.add_argument("--username-only", "-e", action="store_true", help="Only insert username") +group.add_argument("--password-only", "-w", action="store_true", help="Only insert password") +group.add_argument("--totp-only", "-T", action="store_true", help="Only insert totp code") + +stderr = functools.partial(print, file=sys.stderr) + + +class ExitCodes(enum.IntEnum): + SUCCESS = 0 + FAILURE = 1 + # 1 is automatically used if Python throws an exception + NO_PASS_CANDIDATES = 2 + COULD_NOT_MATCH_USERNAME = 3 + COULD_NOT_MATCH_PASSWORD = 4 + + +def qute_command(command): + with open(os.environ["QUTE_FIFO"], "w") as fifo: + fifo.write(command + "\n") + fifo.flush() + + +def ask_password(password_prompt_invocation): + process = subprocess.run( + shlex.split(password_prompt_invocation), + text=True, + stdout=subprocess.PIPE, + ) + if process.returncode > 0: + raise Exception("Could not unlock vault") + master_pass = process.stdout.strip() + return subprocess.check_output( + ["bw", "unlock", "--raw", "--passwordenv", "BW_MASTERPASS"], + env={**os.environ, "BW_MASTERPASS": master_pass}, + text=True, + ).strip() + + +def get_session_key(auto_lock, password_prompt_invocation): + if auto_lock == 0: + subprocess.call(["keyctl", "purge", "user", "bw_session"]) + return ask_password(password_prompt_invocation) + else: + process = subprocess.run( + ["keyctl", "request", "user", "bw_session"], + text=True, + stdout=subprocess.PIPE, + ) + key_id = process.stdout.strip() + if process.returncode > 0: + session = ask_password(password_prompt_invocation) + if not session: + raise Exception("Could not unlock vault") + key_id = subprocess.check_output( + ["keyctl", "add", "user", "bw_session", session, "@u"], + text=True, + ).strip() + + if auto_lock > 0: + subprocess.call(["keyctl", "timeout", str(key_id), str(auto_lock)]) + return subprocess.check_output( + ["keyctl", "pipe", str(key_id)], + text=True, + ).strip() + + +def pass_(domain, encoding, auto_lock, password_prompt_invocation): + session_key = get_session_key(auto_lock, password_prompt_invocation) + process = subprocess.run( + ["bw", "list", "items", "--nointeraction", "--session", session_key, "--url", domain], + capture_output=True, + ) + + err = process.stderr.decode(encoding).strip() + if err: + msg = "Bitwarden CLI returned for {:s} - {:s}".format(domain, err) + stderr(msg) + + if "Vault is locked" in err: + stderr("Bitwarden Vault got locked, trying again with clean session") + return pass_(domain, encoding, 0, password_prompt_invocation) + + if process.returncode: + return "[]" + + out = process.stdout.decode(encoding).strip() + + return out + + +def get_totp_code(selection_id, domain_name, encoding, auto_lock, password_prompt_invocation): + session_key = get_session_key(auto_lock, password_prompt_invocation) + process = subprocess.run( + ["bw", "get", "totp", "--nointeraction", "--session", session_key, selection_id], + capture_output=True, + ) + + err = process.stderr.decode(encoding).strip() + if err: + # domain_name instead of selection_id to make it more user-friendly + msg = "Bitwarden CLI returned for {:s} - {:s}".format(domain_name, err) + stderr(msg) + + if "Vault is locked" in err: + stderr("Bitwarden Vault got locked, trying again with clean session") + return get_totp_code(selection_id, domain_name, encoding, 0, password_prompt_invocation) + + if process.returncode: + return "[]" + + out = process.stdout.decode(encoding).strip() + + return out + + +def dmenu(items, invocation, encoding): + command = shlex.split(invocation) + process = subprocess.run(command, input="\n".join(items).encode(encoding), stdout=subprocess.PIPE) + return process.stdout.decode(encoding).strip() + + +def fake_key_raw(text): + for character in text: + # Escape all characters by default, space requires special handling + sequence = '" "' if character == " " else r"\{}".format(character) + qute_command("fake-key {}".format(sequence)) + + +def main(arguments): + if not arguments.url: + argument_parser.print_help() + return ExitCodes.FAILURE + + extract_result = tldextract.extract(arguments.url) + + # Try to find candidates using targets in the following order: fully-qualified domain name (includes subdomains), + # the registered domain name and finally: the IPv4 address if that's what + # the URL represents + candidates = [] + for target in filter( + None, + [ + extract_result.fqdn, + extract_result.registered_domain, + extract_result.subdomain + "." + extract_result.domain, + extract_result.domain, + extract_result.ipv4, + ], + ): + target_candidates = json.loads( + pass_( + target, + arguments.io_encoding, + arguments.auto_lock, + arguments.password_prompt_invocation, + ) + ) + if not target_candidates: + continue + + candidates = candidates + target_candidates + if not arguments.merge_candidates: + break + else: + if not candidates: + stderr("No pass candidates for URL {!r} found!".format(arguments.url)) + return ExitCodes.NO_PASS_CANDIDATES + + if len(candidates) == 1: + selection = candidates.pop() + else: + choices = ["{:s} | {:s}".format(c["name"], c["login"]["username"]) for c in candidates] + choice = dmenu(choices, arguments.dmenu_invocation, arguments.io_encoding) + choice_tokens = choice.split("|") + choice_name = choice_tokens[0].strip() + choice_username = choice_tokens[1].strip() + selection = next((c for (i, c) in enumerate(candidates) if c["name"] == choice_name and c["login"]["username"] == choice_username), None) + + # Nothing was selected, simply return + if not selection: + return ExitCodes.SUCCESS + + username = selection["login"]["username"] + password = selection["login"]["password"] + totp = selection["login"]["totp"] + + if arguments.username_only: + fake_key_raw(username) + elif arguments.password_only: + fake_key_raw(password) + elif arguments.totp_only: + # No point in moving it to the clipboard in this case + fake_key_raw( + get_totp_code( + selection["id"], + selection["name"], + arguments.io_encoding, + arguments.auto_lock, + arguments.password_prompt_invocation, + ) + ) + else: + # Enter username and password using fake-key and (which seems to work almost universally), then switch + # back into insert-mode, so the form can be directly submitted by + # hitting enter afterwards + fake_key_raw(username) + qute_command("fake-key ") + fake_key_raw(password) + + if arguments.insert_mode: + qute_command("mode-enter insert") + + # If it finds a TOTP code, it copies it to the clipboard, + # which is the same behavior as the Firefox add-on. + if not arguments.totp_only and totp and arguments.totp: + # The import is done here, to make pyperclip an optional dependency + import pyperclip + + pyperclip.copy( + get_totp_code( + selection["id"], + selection["name"], + arguments.io_encoding, + arguments.auto_lock, + arguments.password_prompt_invocation, + ) + ) + + return ExitCodes.SUCCESS + + +if __name__ == "__main__": + arguments = argument_parser.parse_args() + sys.exit(main(arguments)) diff --git a/.local/share/qutebrowser/userscripts/qute-getbib b/.local/share/qutebrowser/userscripts/qute-getbib new file mode 100755 index 0000000..07cd822 --- /dev/null +++ b/.local/share/qutebrowser/userscripts/qute-getbib @@ -0,0 +1,67 @@ +#!/usr/bin/env python3 +"""Qutebrowser userscript scraping the current web page for DOIs and downloading +corresponding bibtex information. + +Set the environment variable 'QUTE_BIB_FILEPATH' to indicate the path to +download to. Otherwise, bibtex information is downloaded to '/tmp' and hence +deleted at reboot. + +Installation: see qute://help/userscripts.html + +Inspired by +https://ocefpaf.github.io/python4oceanographers/blog/2014/05/19/doi2bibtex/ +""" + +import os +import sys +import re +from collections import Counter +from urllib import parse as url_parse +from urllib import request as url_request + + +FIFO_PATH = os.getenv("QUTE_FIFO") + + +def message_fifo(message, level="warning"): + """Send message to qutebrowser FIFO. The level must be one of 'info', + 'warning' (default) or 'error'.""" + with open(FIFO_PATH, "w") as fifo: + fifo.write("message-{} '{}'".format(level, message)) + + +source = os.getenv("QUTE_TEXT") +with open(source) as f: + text = f.read() + +# find DOIs on page using regex +dval = re.compile(r"(10\.(\d)+/([^(\s\>\"\<)])+)") +# https://stackoverflow.com/a/10324802/3865876, too strict +# dval = re.compile(r'\b(10[.][0-9]{4,}(?:[.][0-9]+)*/(?:(?!["&\'<>])\S)+)\b') +dois = dval.findall(text) +dois = Counter(e[0] for e in dois) +try: + doi = dois.most_common(1)[0][0] +except IndexError: + message_fifo("No DOIs found on page") + sys.exit() +message_fifo("Found {} DOIs on page, selecting {}".format(len(dois), doi), level="info") + +# get bibtex data corresponding to DOI +url = "https://dx.doi.org/" + url_parse.quote(doi) +headers = dict(Accept="text/bibliography; style=bibtex") +request = url_request.Request(url, headers=headers) +response = url_request.urlopen(request) +status_code = response.getcode() +if status_code >= 400: + message_fifo("Request returned {}".format(status_code)) + sys.exit() + +# obtain content and format it +bibtex = response.read().decode("utf-8").strip() +bibtex = bibtex.replace(" ", "\n ", 1).replace("}, ", "},\n ").replace("}}", "}\n}") + +# append to file +bib_filepath = os.getenv("QUTE_BIB_FILEPATH", "/tmp/qute.bib") +with open(bib_filepath, "a") as f: + f.write(bibtex + "\n\n") diff --git a/.local/share/qutebrowser/userscripts/qute-scihub b/.local/share/qutebrowser/userscripts/qute-scihub new file mode 100755 index 0000000..7c75616 --- /dev/null +++ b/.local/share/qutebrowser/userscripts/qute-scihub @@ -0,0 +1,53 @@ +#!/usr/bin/env python3 +# doi --- DOI to Sci-Hub + +""" +Usage note + +In order to use this script you need to have a search engine like + + c.url.searchengines['#sci'] = "https://sci-hub.se/{}" + +in your config.py. This is intended to make it easier to update the +Sci-Hub domain should it change again later. At a later date I plan +to write a userscript or addon Aaron Janse’s ‘DNS over Wikipedia’ +extension for Firefox which can look up Wikipedia to find the latest +domain of activist projects like Sci-Hub, Libgen, etc. +""" + +import os +import re + +fifo = open(os.getenv("QUTE_FIFO"), "w") + +mode = os.getenv("QUTE_MODE") + +text = None + +if mode == "hints": + text = os.getenv("QUTE_URL").strip() +elif mode == "command": + text = os.getenv("QUTE_SELECTED_TEXT").strip() + +# DOI syntax: https://www.doi.org/doi_handbook/2_Numbering.html#2.2. +# +# Note that this probably matches a subset of possible DOIs, as it +# seems that there’s no practical limitation on neither the length nor +# the contents of the DOI. But IMHO this is a healthy subset. +doi_re = re.compile( + # match possible URI prefix + r"(?P((https?)?://)?doi\.org/)?" + # match actual DOI + r"(?P[a-zA-Z0-9\./\-_]+)" +) + +match = doi_re.match(text) + +if match is None: + fifo.write(f'message-warning "`{text}\' is probably not a DOI, or update regexp"') + +else: + doi = match["meat"] + fifo.write(f"open -t !sci {doi}") + +fifo.flush()