From f663e6f6908a9dfb05ac22e867e726c1bf6f0960 Mon Sep 17 00:00:00 2001
From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com>
Date: Wed, 11 Jun 2025 00:41:05 +1000
Subject: internal: refactor for packaging

Package using python-build, python-installer and hatch
---
 src/caelestia/parser.py | 125 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 125 insertions(+)
 create mode 100644 src/caelestia/parser.py

(limited to 'src/caelestia/parser.py')

diff --git a/src/caelestia/parser.py b/src/caelestia/parser.py
new file mode 100644
index 0000000..db45645
--- /dev/null
+++ b/src/caelestia/parser.py
@@ -0,0 +1,125 @@
+import argparse
+
+from caelestia.data import get_scheme_names, scheme_variants
+from caelestia.subcommands import (
+    clipboard,
+    emoji,
+    pip,
+    record,
+    scheme,
+    screenshot,
+    shell,
+    toggle,
+    variant,
+    wallpaper,
+    wsaction,
+)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(prog="caelestia", description="Main control script for the Caelestia dotfiles")
+
+    # Add subcommand parsers
+    command_parser = parser.add_subparsers(
+        title="subcommands", description="valid subcommands", metavar="COMMAND", help="the subcommand to run"
+    )
+
+    # Create parser for shell opts
+    shell_parser = command_parser.add_parser("shell", help="start or message the shell")
+    shell_parser.set_defaults(cls=shell.Command)
+    shell_parser.add_argument("message", nargs="*", help="a message to send to the shell")
+    shell_parser.add_argument("-s", "--show", action="store_true", help="print all shell IPC commands")
+    shell_parser.add_argument(
+        "-l",
+        "--log",
+        nargs="?",
+        const="quickshell.dbus.properties.warning=false;quickshell.dbus.dbusmenu.warning=false;quickshell.service.notifications.warning=false;quickshell.service.sni.host.warning=false",
+        metavar="RULES",
+        help="print the shell log",
+    )
+
+    # Create parser for toggle opts
+    toggle_parser = command_parser.add_parser("toggle", help="toggle a special workspace")
+    toggle_parser.set_defaults(cls=toggle.Command)
+    toggle_parser.add_argument(
+        "workspace", choices=["communication", "music", "sysmon", "specialws", "todo"], help="the workspace to toggle"
+    )
+
+    # Create parser for workspace-action opts
+    ws_action_parser = command_parser.add_parser(
+        "workspace-action", help="execute a Hyprland workspace dispatcher in the current group"
+    )
+    ws_action_parser.set_defaults(cls=wsaction.Command)
+    ws_action_parser.add_argument(
+        "-g", "--group", action="store_true", help="whether to execute the dispatcher on a group"
+    )
+    ws_action_parser.add_argument(
+        "dispatcher", choices=["workspace", "movetoworkspace"], help="the dispatcher to execute"
+    )
+    ws_action_parser.add_argument("workspace", type=int, help="the workspace to pass to the dispatcher")
+
+    # Create parser for scheme opts
+    scheme_parser = command_parser.add_parser("scheme", help="manage the colour scheme")
+    scheme_parser.set_defaults(cls=scheme.Command)
+    scheme_parser.add_argument("-g", "--get", action="store_true", help="print the current scheme")
+    scheme_parser.add_argument("-r", "--random", action="store_true", help="switch to a random scheme")
+    scheme_parser.add_argument("-n", "--name", choices=get_scheme_names(), help="the name of the scheme to switch to")
+    scheme_parser.add_argument("-f", "--flavour", help="the flavour to switch to")
+    scheme_parser.add_argument("-m", "--mode", choices=["dark", "light"], help="the mode to switch to")
+
+    # Create parser for variant opts
+    variant_parser = command_parser.add_parser("variant", help="manage the dynamic scheme variant")
+    variant_parser.set_defaults(cls=variant.Command)
+    variant_parser.add_argument("-g", "--get", action="store_true", help="print the current dynamic scheme variant")
+    variant_parser.add_argument("-s", "--set", choices=scheme_variants, help="set the current dynamic scheme variant")
+    variant_parser.add_argument("-r", "--random", action="store_true", help="switch to a random variant")
+
+    # Create parser for screenshot opts
+    screenshot_parser = command_parser.add_parser("screenshot", help="take a screenshot")
+    screenshot_parser.set_defaults(cls=screenshot.Command)
+    screenshot_parser.add_argument("-r", "--region", help="take a screenshot of a region")
+    screenshot_parser.add_argument(
+        "-f", "--freeze", action="store_true", help="freeze the screen while selecting a region"
+    )
+
+    # Create parser for record opts
+    record_parser = command_parser.add_parser("record", help="start a screen recording")
+    record_parser.set_defaults(cls=record.Command)
+    record_parser.add_argument("-r", "--region", action="store_true", help="record a region")
+    record_parser.add_argument("-s", "--sound", action="store_true", help="record audio")
+
+    # Create parser for clipboard opts
+    clipboard_parser = command_parser.add_parser("clipboard", help="open clipboard history")
+    clipboard_parser.set_defaults(cls=clipboard.Command)
+    clipboard_parser.add_argument("-d", "--delete", action="store_true", help="delete from clipboard history")
+
+    # Create parser for emoji-picker opts
+    emoji_parser = command_parser.add_parser("emoji-picker", help="toggle the emoji picker")
+    emoji_parser.set_defaults(cls=emoji.Command)
+
+    # Create parser for wallpaper opts
+    wallpaper_parser = command_parser.add_parser("wallpaper", help="manage the wallpaper")
+    wallpaper_parser.set_defaults(cls=wallpaper.Command)
+    wallpaper_parser.add_argument("-g", "--get", action="store_true", help="print the current wallpaper")
+    wallpaper_parser.add_argument("-r", "--random", action="store_true", help="switch to a random wallpaper")
+    wallpaper_parser.add_argument("-f", "--file", help="the path to the wallpaper to switch to")
+    wallpaper_parser.add_argument("-n", "--no-filter", action="store_true", help="do not filter by size")
+    wallpaper_parser.add_argument(
+        "-t",
+        "--threshold",
+        default=80,
+        help="the minimum percentage of the largest monitor size the image must be greater than to be selected",
+    )
+    wallpaper_parser.add_argument(
+        "-N",
+        "--no-smart",
+        action="store_true",
+        help="do not automatically change the scheme mode based on wallpaper colour",
+    )
+
+    # Create parser for pip opts
+    pip_parser = command_parser.add_parser("pip", help="picture in picture utilities")
+    pip_parser.set_defaults(cls=pip.Command)
+    pip_parser.add_argument("-d", "--daemon", action="store_true", help="start the daemon")
+
+    return parser.parse_args()
-- 
cgit v1.2.3-freya


From a4f5138d41bee1562743e645cf937c24fcec36ea Mon Sep 17 00:00:00 2001
From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com>
Date: Wed, 11 Jun 2025 15:43:32 +1000
Subject: parser: print help when no args

Also create utility script for testing
---
 run.sh                    | 11 +++++++++++
 src/caelestia/__init__.py |  6 +++---
 src/caelestia/parser.py   |  4 ++--
 3 files changed, 16 insertions(+), 5 deletions(-)
 create mode 100755 run.sh

(limited to 'src/caelestia/parser.py')

diff --git a/run.sh b/run.sh
new file mode 100755
index 0000000..9734996
--- /dev/null
+++ b/run.sh
@@ -0,0 +1,11 @@
+#!/usr/bin/env sh
+
+# Utility script for rebuilding and running caelestia
+
+cd $(dirname $0) || exit
+
+sudo rm -r dist /usr/bin/caelestia /usr/lib/python3.*/site-packages/caelestia* 2> /dev/null
+python -m build --wheel --no-isolation > /dev/null
+sudo python -m installer --destdir=/ dist/*.whl > /dev/null
+
+/usr/bin/caelestia "$@"
diff --git a/src/caelestia/__init__.py b/src/caelestia/__init__.py
index 074c1b9..71c9b62 100644
--- a/src/caelestia/__init__.py
+++ b/src/caelestia/__init__.py
@@ -2,12 +2,12 @@ from caelestia.parser import parse_args
 
 
 def main() -> None:
-    args = parse_args()
+    parser, args = parse_args()
     if "cls" in args:
         args.cls(args).run()
     else:
-        import sys
-        print("No arguments given", file=sys.stderr)
+        parser.print_help()
+
 
 if __name__ == "__main__":
     main()
diff --git a/src/caelestia/parser.py b/src/caelestia/parser.py
index db45645..00556b0 100644
--- a/src/caelestia/parser.py
+++ b/src/caelestia/parser.py
@@ -16,7 +16,7 @@ from caelestia.subcommands import (
 )
 
 
-def parse_args() -> argparse.Namespace:
+def parse_args() -> (argparse.ArgumentParser, argparse.Namespace):
     parser = argparse.ArgumentParser(prog="caelestia", description="Main control script for the Caelestia dotfiles")
 
     # Add subcommand parsers
@@ -122,4 +122,4 @@ def parse_args() -> argparse.Namespace:
     pip_parser.set_defaults(cls=pip.Command)
     pip_parser.add_argument("-d", "--daemon", action="store_true", help="start the daemon")
 
-    return parser.parse_args()
+    return parser, parser.parse_args()
-- 
cgit v1.2.3-freya


From dc855e1b01e9b4526927b8bd69daca733afd97c2 Mon Sep 17 00:00:00 2001
From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com>
Date: Wed, 11 Jun 2025 17:37:04 +1000
Subject: internal: refactor scheme

Also use a single file to store scheme data
---
 src/caelestia/data.py              | 120 -----------------------
 src/caelestia/parser.py            |   2 +-
 src/caelestia/subcommands/shell.py |   4 +-
 src/caelestia/utils/hypr.py        |   2 +-
 src/caelestia/utils/paths.py       |  13 +++
 src/caelestia/utils/scheme.py      | 194 +++++++++++++++++++++++++++++++++++++
 6 files changed, 211 insertions(+), 124 deletions(-)
 delete mode 100644 src/caelestia/data.py
 create mode 100644 src/caelestia/utils/paths.py

(limited to 'src/caelestia/parser.py')

diff --git a/src/caelestia/data.py b/src/caelestia/data.py
deleted file mode 100644
index fa97a03..0000000
--- a/src/caelestia/data.py
+++ /dev/null
@@ -1,120 +0,0 @@
-import os
-from pathlib import Path
-
-config_dir = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config"))
-data_dir = Path(os.getenv("XDG_DATA_HOME", Path.home() / ".local/share"))
-state_dir = Path(os.getenv("XDG_STATE_HOME", Path.home() / ".local/state"))
-
-c_config_dir = config_dir / "caelestia"
-c_data_dir = data_dir / "caelestia"
-c_state_dir = state_dir / "caelestia"
-
-scheme_name_path = c_state_dir / "scheme/name.txt"
-scheme_flavour_path = c_state_dir / "scheme/flavour.txt"
-scheme_colours_path = c_state_dir / "scheme/colours.txt"
-scheme_mode_path = c_state_dir / "scheme/mode.txt"
-scheme_variant_path = c_state_dir / "scheme/variant.txt"
-
-scheme_data_path = Path(__file__).parent / "data/schemes"
-
-scheme_variants = [
-    "tonalspot",
-    "vibrant",
-    "expressive",
-    "fidelity",
-    "fruitsalad",
-    "monochrome",
-    "neutral",
-    "rainbow",
-    "content",
-]
-
-scheme_names: list[str] = None
-scheme_flavours: list[str] = None
-scheme_modes: list[str] = None
-
-scheme_name: str = None
-scheme_flavour: str = None
-scheme_colours: dict[str, str] = None
-scheme_mode: str = None
-scheme_variant: str = None
-
-
-def get_scheme_path() -> Path:
-    return (scheme_data_path / get_scheme_name() / get_scheme_flavour() / get_scheme_mode()).with_suffix(".txt")
-
-
-def get_scheme_names() -> list[str]:
-    global scheme_names
-
-    if scheme_names is None:
-        scheme_names = [f.name for f in scheme_data_path.iterdir() if f.is_dir()]
-
-    return scheme_names
-
-
-def get_scheme_flavours() -> list[str]:
-    global scheme_flavours
-
-    if scheme_flavours is None:
-        scheme_flavours = [f.name for f in (scheme_data_path / get_scheme_name()).iterdir() if f.is_dir()]
-
-    return scheme_flavours
-
-
-def get_scheme_modes() -> list[str]:
-    global scheme_modes
-
-    if scheme_modes is None:
-        scheme_modes = [
-            f.stem for f in (scheme_data_path / get_scheme_name() / get_scheme_flavour()).iterdir() if f.is_file()
-        ]
-
-    return scheme_modes
-
-
-def get_scheme_name() -> str:
-    global scheme_name
-
-    if scheme_name is None:
-        scheme_name = scheme_name_path.read_text().strip() if scheme_name_path.exists() else "catppuccin"
-
-    return scheme_name
-
-
-def get_scheme_flavour() -> str:
-    global scheme_flavour
-
-    if scheme_flavour is None:
-        scheme_flavour = scheme_flavour_path.read_text().strip() if scheme_flavour_path.exists() else "mocha"
-
-    return scheme_flavour
-
-
-def get_scheme_colours() -> dict[str, str]:
-    global scheme_colours
-
-    if scheme_colours is None:
-        scheme_colours = {
-            k.strip(): v.strip() for k, v in (line.split(" ") for line in get_scheme_path().read_text().splitlines())
-        }
-
-    return scheme_colours
-
-
-def get_scheme_mode() -> str:
-    global scheme_mode
-
-    if scheme_mode is None:
-        scheme_mode = scheme_mode_path.read_text().strip() if scheme_mode_path.exists() else "dark"
-
-    return scheme_mode
-
-
-def get_scheme_variant() -> str:
-    global scheme_variant
-
-    if scheme_variant is None:
-        scheme_variant = scheme_variant_path.read_text().strip() if scheme_variant_path.exists() else "tonalspot"
-
-    return scheme_variant
diff --git a/src/caelestia/parser.py b/src/caelestia/parser.py
index 00556b0..eb8734e 100644
--- a/src/caelestia/parser.py
+++ b/src/caelestia/parser.py
@@ -1,6 +1,5 @@
 import argparse
 
-from caelestia.data import get_scheme_names, scheme_variants
 from caelestia.subcommands import (
     clipboard,
     emoji,
@@ -14,6 +13,7 @@ from caelestia.subcommands import (
     wallpaper,
     wsaction,
 )
+from caelestia.utils.scheme import get_scheme_names, scheme_variants
 
 
 def parse_args() -> (argparse.ArgumentParser, argparse.Namespace):
diff --git a/src/caelestia/subcommands/shell.py b/src/caelestia/subcommands/shell.py
index 2d8d14e..25a39d8 100644
--- a/src/caelestia/subcommands/shell.py
+++ b/src/caelestia/subcommands/shell.py
@@ -1,7 +1,7 @@
 import subprocess
 from argparse import Namespace
 
-from caelestia import data
+from caelestia.utils import paths
 
 
 class Command:
@@ -25,7 +25,7 @@ class Command:
             self.shell()
 
     def shell(self, *args: list[str]) -> str:
-        return subprocess.check_output(["qs", "-p", data.c_data_dir / "shell", *args], text=True)
+        return subprocess.check_output(["qs", "-p", paths.c_data_dir / "shell", *args], text=True)
 
     def print_ipc(self) -> None:
         print(self.shell("ipc", "show"), end="")
diff --git a/src/caelestia/utils/hypr.py b/src/caelestia/utils/hypr.py
index d829f22..621e28e 100644
--- a/src/caelestia/utils/hypr.py
+++ b/src/caelestia/utils/hypr.py
@@ -5,7 +5,7 @@ import socket
 socket_path = f"{os.getenv('XDG_RUNTIME_DIR')}/hypr/{os.getenv('HYPRLAND_INSTANCE_SIGNATURE')}/.socket.sock"
 
 
-def message(msg: str, json: bool = True) -> str or dict[str, any]:
+def message(msg: str, json: bool = True) -> str | dict[str, any]:
     with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
         sock.connect(socket_path)
 
diff --git a/src/caelestia/utils/paths.py b/src/caelestia/utils/paths.py
new file mode 100644
index 0000000..aff6ea0
--- /dev/null
+++ b/src/caelestia/utils/paths.py
@@ -0,0 +1,13 @@
+import os
+from pathlib import Path
+
+config_dir = Path(os.getenv("XDG_CONFIG_HOME", Path.home() / ".config"))
+data_dir = Path(os.getenv("XDG_DATA_HOME", Path.home() / ".local/share"))
+state_dir = Path(os.getenv("XDG_STATE_HOME", Path.home() / ".local/state"))
+
+c_config_dir = config_dir / "caelestia"
+c_data_dir = data_dir / "caelestia"
+c_state_dir = state_dir / "caelestia"
+
+scheme_path = c_state_dir / "scheme.json"
+scheme_data_path = Path(__file__).parent.parent / "data/schemes"
diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py
index e69de29..79a0c21 100644
--- a/src/caelestia/utils/scheme.py
+++ b/src/caelestia/utils/scheme.py
@@ -0,0 +1,194 @@
+import json
+from pathlib import Path
+
+from caelestia.utils.paths import scheme_data_path, scheme_path
+
+
+class Scheme:
+    _name: str
+    _flavour: str
+    _mode: str
+    _variant: str
+    _colours: dict[str, str]
+
+    def __init__(self, json: dict[str, any] | None) -> None:
+        if json is None:
+            self._name = "catppuccin"
+            self._flavour = "mocha"
+            self._mode = "dark"
+            self._variant = "tonalspot"
+            self._colours = read_colours_from_file(self.get_colours_path())
+        else:
+            self._name = json["name"]
+            self._flavour = json["flavour"]
+            self._mode = json["mode"]
+            self._variant = json["variant"]
+            self._colours = json["colours"]
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @name.setter
+    def name(self, name: str) -> None:
+        if name == self._name:
+            return
+
+        if name not in get_scheme_names():
+            raise ValueError(f"Invalid scheme name: {name}")
+
+        self._name = name
+        self._check_flavour()
+        self._check_mode()
+        self._update_colours()
+        self.save()
+
+    @property
+    def flavour(self) -> str:
+        return self._flavour
+
+    @flavour.setter
+    def flavour(self, flavour: str) -> None:
+        if flavour == self._flavour:
+            return
+
+        if flavour not in get_scheme_flavours():
+            raise ValueError(f"Invalid scheme flavour: {flavour}")
+
+        self._flavour = flavour
+        self._check_mode()
+        self._update_colours()
+        self.save()
+
+    @property
+    def mode(self) -> str:
+        return self._mode
+
+    @mode.setter
+    def mode(self, mode: str) -> None:
+        if mode == self._mode:
+            return
+
+        if mode not in get_scheme_modes():
+            raise ValueError(f"Invalid scheme mode: {mode}")
+
+        self._mode = mode
+        self._update_colours()
+        self.save()
+
+    @property
+    def variant(self) -> str:
+        return self._variant
+
+    @variant.setter
+    def variant(self, variant: str) -> None:
+        self._variant = variant
+
+    @property
+    def colours(self) -> dict[str, str]:
+        return self._colours
+
+    def get_colours_path(self) -> Path:
+        return (scheme_data_path / self.name / self.flavour / self.mode).with_suffix(".txt")
+
+    def save(self) -> None:
+        scheme_path.parent.mkdir(parents=True, exist_ok=True)
+        with scheme_path.open("w") as f:
+            json.dump(
+                {
+                    "name": self.name,
+                    "flavour": self.flavour,
+                    "mode": self.mode,
+                    "variant": self.variant,
+                    "colours": self.colours,
+                },
+                f,
+            )
+
+    def _check_flavour(self) -> None:
+        global scheme_flavours
+        scheme_flavours = None
+        if self._flavour not in get_scheme_flavours():
+            self._flavour = get_scheme_flavours()[0]
+
+    def _check_mode(self) -> None:
+        global scheme_modes
+        scheme_modes = None
+        if self._mode not in get_scheme_modes():
+            self._mode = get_scheme_modes()[0]
+
+    def _update_colours(self) -> None:
+        self._colours = read_colours_from_file(self.get_colours_path())
+
+
+scheme_variants = [
+    "tonalspot",
+    "vibrant",
+    "expressive",
+    "fidelity",
+    "fruitsalad",
+    "monochrome",
+    "neutral",
+    "rainbow",
+    "content",
+]
+
+scheme_names: list[str] = None
+scheme_flavours: list[str] = None
+scheme_modes: list[str] = None
+
+scheme: Scheme = None
+
+
+def read_colours_from_file(path: Path) -> dict[str, str]:
+    return {k.strip(): v.strip() for k, v in (line.split(" ") for line in path.read_text().splitlines())}
+
+
+def get_scheme_path() -> Path:
+    return get_scheme().get_colours_path()
+
+
+def get_scheme() -> Scheme:
+    global scheme
+
+    if scheme is None:
+        try:
+            scheme_json = json.loads(scheme_path.read_text())
+            scheme = Scheme(scheme_json)
+        except (IOError, json.JSONDecodeError):
+            scheme = Scheme(None)
+
+    return scheme
+
+
+def get_scheme_names() -> list[str]:
+    global scheme_names
+
+    if scheme_names is None:
+        scheme_names = [f.name for f in scheme_data_path.iterdir() if f.is_dir()]
+        scheme_names.append("dynamic")
+
+    return scheme_names
+
+
+def get_scheme_flavours() -> list[str]:
+    global scheme_flavours
+
+    if scheme_flavours is None:
+        name = get_scheme().name
+        if name == "dynamic":
+            scheme_flavours = ["default", "alt1", "alt2"]
+        else:
+            scheme_flavours = [f.name for f in (scheme_data_path / name).iterdir() if f.is_dir()]
+
+    return scheme_flavours
+
+
+def get_scheme_modes() -> list[str]:
+    global scheme_modes
+
+    if scheme_modes is None:
+        scheme = get_scheme()
+        scheme_modes = [f.stem for f in (scheme_data_path / scheme.name / scheme.flavour).iterdir() if f.is_file()]
+
+    return scheme_modes
-- 
cgit v1.2.3-freya


From f43987ef2f55ede746c5cc37567f5e74ba515fb3 Mon Sep 17 00:00:00 2001
From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com>
Date: Wed, 11 Jun 2025 18:07:34 +1000
Subject: feat: impl scheme command (partial)

---
 src/caelestia/parser.py             |  1 -
 src/caelestia/subcommands/scheme.py | 16 +++++++++++++++-
 src/caelestia/utils/scheme.py       |  3 +++
 3 files changed, 18 insertions(+), 2 deletions(-)

(limited to 'src/caelestia/parser.py')

diff --git a/src/caelestia/parser.py b/src/caelestia/parser.py
index eb8734e..9718938 100644
--- a/src/caelestia/parser.py
+++ b/src/caelestia/parser.py
@@ -61,7 +61,6 @@ def parse_args() -> (argparse.ArgumentParser, argparse.Namespace):
     # Create parser for scheme opts
     scheme_parser = command_parser.add_parser("scheme", help="manage the colour scheme")
     scheme_parser.set_defaults(cls=scheme.Command)
-    scheme_parser.add_argument("-g", "--get", action="store_true", help="print the current scheme")
     scheme_parser.add_argument("-r", "--random", action="store_true", help="switch to a random scheme")
     scheme_parser.add_argument("-n", "--name", choices=get_scheme_names(), help="the name of the scheme to switch to")
     scheme_parser.add_argument("-f", "--flavour", help="the flavour to switch to")
diff --git a/src/caelestia/subcommands/scheme.py b/src/caelestia/subcommands/scheme.py
index 37f9a2b..19e62db 100644
--- a/src/caelestia/subcommands/scheme.py
+++ b/src/caelestia/subcommands/scheme.py
@@ -1,5 +1,7 @@
 from argparse import Namespace
 
+from caelestia.utils.scheme import get_scheme
+
 
 class Command:
     args: Namespace
@@ -8,4 +10,16 @@ class Command:
         self.args = args
 
     def run(self) -> None:
-        pass
+        scheme = get_scheme()
+
+        if self.args.random:
+            scheme.set_random()
+        elif self.args.name or self.args.flavour or self.args.mode:
+            if self.args.name:
+                scheme.name = self.args.name
+            if self.args.flavour:
+                scheme.flavour = self.args.flavour
+            if self.args.mode:
+                scheme.mode = self.args.mode
+        else:
+            print(scheme)
diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py
index 79a0c21..4b05100 100644
--- a/src/caelestia/utils/scheme.py
+++ b/src/caelestia/utils/scheme.py
@@ -120,6 +120,9 @@ class Scheme:
     def _update_colours(self) -> None:
         self._colours = read_colours_from_file(self.get_colours_path())
 
+    def __str__(self) -> str:
+        return f"Scheme(name={self.name}, flavour={self.flavour}, mode={self.mode}, variant={self.variant})"
+
 
 scheme_variants = [
     "tonalspot",
-- 
cgit v1.2.3-freya


From e75e727262573de25ee1e1e75bd93e3647dc3609 Mon Sep 17 00:00:00 2001
From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com>
Date: Thu, 12 Jun 2025 16:23:14 +1000
Subject: scheme: add variant option

Remove variant subcommand
---
 src/caelestia/parser.py              | 22 ++--------------------
 src/caelestia/subcommands/scheme.py  |  4 +++-
 src/caelestia/subcommands/variant.py | 11 -----------
 src/caelestia/utils/scheme.py        |  5 +++++
 4 files changed, 10 insertions(+), 32 deletions(-)
 delete mode 100644 src/caelestia/subcommands/variant.py

(limited to 'src/caelestia/parser.py')

diff --git a/src/caelestia/parser.py b/src/caelestia/parser.py
index 9718938..3f6f506 100644
--- a/src/caelestia/parser.py
+++ b/src/caelestia/parser.py
@@ -1,18 +1,6 @@
 import argparse
 
-from caelestia.subcommands import (
-    clipboard,
-    emoji,
-    pip,
-    record,
-    scheme,
-    screenshot,
-    shell,
-    toggle,
-    variant,
-    wallpaper,
-    wsaction,
-)
+from caelestia.subcommands import clipboard, emoji, pip, record, scheme, screenshot, shell, toggle, wallpaper, wsaction
 from caelestia.utils.scheme import get_scheme_names, scheme_variants
 
 
@@ -65,13 +53,7 @@ def parse_args() -> (argparse.ArgumentParser, argparse.Namespace):
     scheme_parser.add_argument("-n", "--name", choices=get_scheme_names(), help="the name of the scheme to switch to")
     scheme_parser.add_argument("-f", "--flavour", help="the flavour to switch to")
     scheme_parser.add_argument("-m", "--mode", choices=["dark", "light"], help="the mode to switch to")
-
-    # Create parser for variant opts
-    variant_parser = command_parser.add_parser("variant", help="manage the dynamic scheme variant")
-    variant_parser.set_defaults(cls=variant.Command)
-    variant_parser.add_argument("-g", "--get", action="store_true", help="print the current dynamic scheme variant")
-    variant_parser.add_argument("-s", "--set", choices=scheme_variants, help="set the current dynamic scheme variant")
-    variant_parser.add_argument("-r", "--random", action="store_true", help="switch to a random variant")
+    scheme_parser.add_argument("-v", "--variant", choices=scheme_variants, help="the variant to switch to")
 
     # Create parser for screenshot opts
     screenshot_parser = command_parser.add_parser("screenshot", help="take a screenshot")
diff --git a/src/caelestia/subcommands/scheme.py b/src/caelestia/subcommands/scheme.py
index 973cfce..c95df96 100644
--- a/src/caelestia/subcommands/scheme.py
+++ b/src/caelestia/subcommands/scheme.py
@@ -16,13 +16,15 @@ class Command:
         if self.args.random:
             scheme.set_random()
             apply_colours(scheme.colours, scheme.mode)
-        elif self.args.name or self.args.flavour or self.args.mode:
+        elif self.args.name or self.args.flavour or self.args.mode or self.args.variant:
             if self.args.name:
                 scheme.name = self.args.name
             if self.args.flavour:
                 scheme.flavour = self.args.flavour
             if self.args.mode:
                 scheme.mode = self.args.mode
+            if self.args.variant:
+                scheme.variant = self.args.variant
             apply_colours(scheme.colours, scheme.mode)
         else:
             print(scheme)
diff --git a/src/caelestia/subcommands/variant.py b/src/caelestia/subcommands/variant.py
deleted file mode 100644
index 37f9a2b..0000000
--- a/src/caelestia/subcommands/variant.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from argparse import Namespace
-
-
-class Command:
-    args: Namespace
-
-    def __init__(self, args: Namespace) -> None:
-        self.args = args
-
-    def run(self) -> None:
-        pass
diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py
index f25cf62..c978231 100644
--- a/src/caelestia/utils/scheme.py
+++ b/src/caelestia/utils/scheme.py
@@ -84,7 +84,12 @@ class Scheme:
 
     @variant.setter
     def variant(self, variant: str) -> None:
+        if variant == self._variant:
+            return
+
         self._variant = variant
+        self._update_colours()
+        self.save()
 
     @property
     def colours(self) -> dict[str, str]:
-- 
cgit v1.2.3-freya


From c043a14ca24f70e81b69133350a1174d2e6572fc Mon Sep 17 00:00:00 2001
From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com>
Date: Thu, 12 Jun 2025 21:35:05 +1000
Subject: feat: impl wallpaper

---
 src/caelestia/parser.py                |  12 +++-
 src/caelestia/subcommands/wallpaper.py |  12 +++-
 src/caelestia/utils/paths.py           |   7 +-
 src/caelestia/utils/scheme.py          |  12 ++--
 src/caelestia/utils/wallpaper.py       | 123 +++++++++++++++++++++++++++++++++
 5 files changed, 154 insertions(+), 12 deletions(-)
 create mode 100644 src/caelestia/utils/wallpaper.py

(limited to 'src/caelestia/parser.py')

diff --git a/src/caelestia/parser.py b/src/caelestia/parser.py
index 3f6f506..f8c7bac 100644
--- a/src/caelestia/parser.py
+++ b/src/caelestia/parser.py
@@ -1,7 +1,9 @@
 import argparse
 
 from caelestia.subcommands import clipboard, emoji, pip, record, scheme, screenshot, shell, toggle, wallpaper, wsaction
+from caelestia.utils.paths import wallpapers_dir
 from caelestia.utils.scheme import get_scheme_names, scheme_variants
+from caelestia.utils.wallpaper import get_wallpaper
 
 
 def parse_args() -> (argparse.ArgumentParser, argparse.Namespace):
@@ -81,14 +83,18 @@ def parse_args() -> (argparse.ArgumentParser, argparse.Namespace):
     # Create parser for wallpaper opts
     wallpaper_parser = command_parser.add_parser("wallpaper", help="manage the wallpaper")
     wallpaper_parser.set_defaults(cls=wallpaper.Command)
-    wallpaper_parser.add_argument("-g", "--get", action="store_true", help="print the current wallpaper")
-    wallpaper_parser.add_argument("-r", "--random", action="store_true", help="switch to a random wallpaper")
+    wallpaper_parser.add_argument(
+        "-p", "--print", nargs="?", const=get_wallpaper(), metavar="PATH", help="print the scheme for a wallpaper"
+    )
+    wallpaper_parser.add_argument(
+        "-r", "--random", nargs="?", const=wallpapers_dir, metavar="DIR", help="switch to a random wallpaper"
+    )
     wallpaper_parser.add_argument("-f", "--file", help="the path to the wallpaper to switch to")
     wallpaper_parser.add_argument("-n", "--no-filter", action="store_true", help="do not filter by size")
     wallpaper_parser.add_argument(
         "-t",
         "--threshold",
-        default=80,
+        default=0.8,
         help="the minimum percentage of the largest monitor size the image must be greater than to be selected",
     )
     wallpaper_parser.add_argument(
diff --git a/src/caelestia/subcommands/wallpaper.py b/src/caelestia/subcommands/wallpaper.py
index 37f9a2b..1440484 100644
--- a/src/caelestia/subcommands/wallpaper.py
+++ b/src/caelestia/subcommands/wallpaper.py
@@ -1,5 +1,8 @@
+import json
 from argparse import Namespace
 
+from caelestia.utils.wallpaper import get_colours_for_wall, get_wallpaper, set_random, set_wallpaper
+
 
 class Command:
     args: Namespace
@@ -8,4 +11,11 @@ class Command:
         self.args = args
 
     def run(self) -> None:
-        pass
+        if self.args.print:
+            print(json.dumps(get_colours_for_wall(self.args.print, self.args.no_smart)))
+        elif self.args.file:
+            set_wallpaper(self.args.file, self.args.no_smart)
+        elif self.args.random:
+            set_random(self.args)
+        else:
+            print(get_wallpaper())
diff --git a/src/caelestia/utils/paths.py b/src/caelestia/utils/paths.py
index 3b5a7a6..f81b996 100644
--- a/src/caelestia/utils/paths.py
+++ b/src/caelestia/utils/paths.py
@@ -22,11 +22,14 @@ scheme_path = c_state_dir / "scheme.json"
 scheme_data_dir = cli_data_dir / "schemes"
 scheme_cache_dir = c_cache_dir / "schemes"
 
-last_wallpaper_path = c_state_dir / "wallpaper/last.txt"
+wallpapers_dir = Path.home() / "Pictures/Wallpapers"
+wallpaper_path_path = c_state_dir / "wallpaper/path.txt"
+wallpaper_link_path = c_state_dir / "wallpaper/current"
 wallpaper_thumbnail_path = c_state_dir / "wallpaper/thumbnail.jpg"
+thumbnail_cache_dir = c_cache_dir / "thumbnails"
 
 
-def compute_hash(path: str) -> str:
+def compute_hash(path: Path | str) -> str:
     sha = hashlib.sha256()
 
     with open(path, "rb") as f:
diff --git a/src/caelestia/utils/scheme.py b/src/caelestia/utils/scheme.py
index 9027589..0d6cfb5 100644
--- a/src/caelestia/utils/scheme.py
+++ b/src/caelestia/utils/scheme.py
@@ -59,8 +59,7 @@ class Scheme:
 
         self._flavour = flavour
         self._check_mode()
-        self._update_colours()
-        self.save()
+        self.update_colours()
 
     @property
     def mode(self) -> str:
@@ -75,8 +74,7 @@ class Scheme:
             raise ValueError(f'Invalid scheme mode: "{mode}". Valid modes: {get_scheme_modes()}')
 
         self._mode = mode
-        self._update_colours()
-        self.save()
+        self.update_colours()
 
     @property
     def variant(self) -> str:
@@ -88,8 +86,7 @@ class Scheme:
             return
 
         self._variant = variant
-        self._update_colours()
-        self.save()
+        self.update_colours()
 
     @property
     def colours(self) -> dict[str, str]:
@@ -115,6 +112,9 @@ class Scheme:
         self._name = random.choice(get_scheme_names())
         self._flavour = random.choice(get_scheme_flavours())
         self._mode = random.choice(get_scheme_modes())
+        self.update_colours()
+
+    def update_colours(self) -> None:
         self._update_colours()
         self.save()
 
diff --git a/src/caelestia/utils/wallpaper.py b/src/caelestia/utils/wallpaper.py
new file mode 100644
index 0000000..c8b3a72
--- /dev/null
+++ b/src/caelestia/utils/wallpaper.py
@@ -0,0 +1,123 @@
+import random
+from argparse import Namespace
+from pathlib import Path
+
+from materialyoucolor.hct import Hct
+from materialyoucolor.utils.color_utils import argb_from_rgb
+from PIL import Image
+
+from caelestia.utils.hypr import message
+from caelestia.utils.material import get_colours_for_image
+from caelestia.utils.paths import (
+    compute_hash,
+    thumbnail_cache_dir,
+    wallpaper_link_path,
+    wallpaper_path_path,
+    wallpaper_thumbnail_path,
+)
+from caelestia.utils.scheme import Scheme, get_scheme
+from caelestia.utils.theme import apply_colours
+
+
+def is_valid_image(path: Path | str) -> bool:
+    path = Path(path)
+    return path.is_file() and path.suffix in [".jpg", ".jpeg", ".png", ".webp", ".tif", ".tiff"]
+
+
+def check_wall(wall: Path, filter_size: tuple[int, int], threshold: float) -> bool:
+    with Image.open(wall) as img:
+        width, height = img.size
+        return width >= filter_size[0] * threshold and height >= filter_size[1] * threshold
+
+
+def get_wallpaper() -> str:
+    return wallpaper_path_path.read_text()
+
+
+def get_wallpapers(args: Namespace) -> list[Path]:
+    dir = Path(args.random)
+    if not dir.is_dir():
+        return []
+
+    walls = [f for f in dir.rglob("*") if is_valid_image(f)]
+
+    if args.no_filter:
+        return walls
+
+    monitors = message("monitors")
+    filter_size = monitors[0]["width"], monitors[0]["height"]
+    for monitor in monitors[1:]:
+        if filter_size[0] > monitor["width"]:
+            filter_size[0] = monitor["width"]
+        if filter_size[1] > monitor["height"]:
+            filter_size[1] = monitor["height"]
+
+    return [f for f in walls if check_wall(f, filter_size, args.threshold)]
+
+
+def get_thumb(wall: Path) -> Path:
+    thumb = (thumbnail_cache_dir / compute_hash(wall)).with_suffix(".jpg")
+
+    if not thumb.exists():
+        with Image.open(wall) as img:
+            img = img.convert("RGB")
+            img.thumbnail((128, 128), Image.NEAREST)
+            thumb.parent.mkdir(parents=True, exist_ok=True)
+            img.save(thumb, "JPEG")
+
+    return thumb
+
+
+def get_smart_mode(wall: Path) -> str:
+    with Image.open(get_thumb(wall)) as img:
+        img.thumbnail((1, 1), Image.LANCZOS)
+        tone = Hct.from_int(argb_from_rgb(*img.getpixel((0, 0)))).tone
+    return "light" if tone > 60 else "dark"
+
+
+def get_colours_for_wall(wall: Path | str, no_smart: bool) -> None:
+    scheme = get_scheme()
+
+    if not no_smart:
+        scheme = Scheme(
+            {
+                "name": scheme.name,
+                "flavour": scheme.flavour,
+                "mode": get_smart_mode(wall),
+                "variant": scheme.variant,
+                "colours": scheme.colours,
+            }
+        )
+
+    return get_colours_for_image(get_thumb(wall), scheme)
+
+
+def set_wallpaper(wall: Path | str, no_smart: bool) -> None:
+    if not is_valid_image(wall):
+        raise ValueError(f'"{wall}" is not a valid image')
+
+    # Update files
+    wallpaper_path_path.parent.mkdir(parents=True, exist_ok=True)
+    wallpaper_path_path.write_text(str(wall))
+    wallpaper_link_path.parent.mkdir(parents=True, exist_ok=True)
+    wallpaper_link_path.unlink(missing_ok=True)
+    wallpaper_link_path.symlink_to(wall)
+
+    # Generate thumbnail or get from cache
+    thumb = get_thumb(wall)
+    wallpaper_thumbnail_path.parent.mkdir(parents=True, exist_ok=True)
+    wallpaper_thumbnail_path.unlink(missing_ok=True)
+    wallpaper_thumbnail_path.symlink_to(thumb)
+
+    scheme = get_scheme()
+
+    # Change mode based on wallpaper colour
+    scheme.mode = get_smart_mode(wall)
+
+    # Update colours
+    scheme.update_colours()
+    apply_colours(scheme.colours, scheme.mode)
+
+
+def set_random(args: Namespace) -> None:
+    set_wallpaper(random.choice(get_wallpapers(args)), args.no_smart)
-- 
cgit v1.2.3-freya


From 796d538b168855ebd2afd62278800151816adcab Mon Sep 17 00:00:00 2001
From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com>
Date: Fri, 13 Jun 2025 00:42:46 +1000
Subject: feat: impl screenshot command

---
 src/caelestia/parser.py                 |  2 +-
 src/caelestia/subcommands/screenshot.py | 69 ++++++++++++++++++++++++++++++++-
 src/caelestia/subcommands/toggle.py     | 14 +------
 src/caelestia/utils/paths.py            |  3 ++
 4 files changed, 74 insertions(+), 14 deletions(-)

(limited to 'src/caelestia/parser.py')

diff --git a/src/caelestia/parser.py b/src/caelestia/parser.py
index f8c7bac..02ac3b9 100644
--- a/src/caelestia/parser.py
+++ b/src/caelestia/parser.py
@@ -60,7 +60,7 @@ def parse_args() -> (argparse.ArgumentParser, argparse.Namespace):
     # Create parser for screenshot opts
     screenshot_parser = command_parser.add_parser("screenshot", help="take a screenshot")
     screenshot_parser.set_defaults(cls=screenshot.Command)
-    screenshot_parser.add_argument("-r", "--region", help="take a screenshot of a region")
+    screenshot_parser.add_argument("-r", "--region", nargs="?", const="slurp", help="take a screenshot of a region")
     screenshot_parser.add_argument(
         "-f", "--freeze", action="store_true", help="freeze the screen while selecting a region"
     )
diff --git a/src/caelestia/subcommands/screenshot.py b/src/caelestia/subcommands/screenshot.py
index 37f9a2b..73d65f7 100644
--- a/src/caelestia/subcommands/screenshot.py
+++ b/src/caelestia/subcommands/screenshot.py
@@ -1,4 +1,9 @@
+import subprocess
 from argparse import Namespace
+from datetime import datetime
+
+from caelestia.utils import hypr
+from caelestia.utils.paths import screenshots_cache_dir, screenshots_dir
 
 
 class Command:
@@ -8,4 +13,66 @@ class Command:
         self.args = args
 
     def run(self) -> None:
-        pass
+        if self.args.region:
+            self.region()
+        else:
+            self.fullscreen()
+
+    def region(self) -> None:
+        freeze_proc = None
+
+        if self.args.freeze:
+            freeze_proc = subprocess.Popen(["wayfreeze", "--hide-cursor"])
+
+        if self.args.region == "slurp":
+            ws = hypr.message("activeworkspace")["id"]
+            geoms = [
+                f"{','.join(map(str, c['at']))} {'x'.join(map(str, c['size']))}"
+                for c in hypr.message("clients")
+                if c["workspace"]["id"] == ws
+            ]
+            region = subprocess.check_output(["slurp"], input="\n".join(geoms), text=True)
+        else:
+            region = self.args.region
+
+        sc_data = subprocess.check_output(["grim", "-l", "0", "-g", region.strip(), "-"])
+        swappy = subprocess.Popen(["swappy", "-f", "-"], stdin=subprocess.PIPE, start_new_session=True)
+        swappy.stdin.write(sc_data)
+        swappy.stdin.close()
+
+        if freeze_proc:
+            freeze_proc.kill()
+
+    def fullscreen(self) -> None:
+        sc_data = subprocess.check_output(["grim", "-"])
+
+        subprocess.run(["wl-copy"], input=sc_data)
+
+        dest = screenshots_cache_dir / datetime.now().strftime("%Y%m%d%H%M%S")
+        screenshots_cache_dir.mkdir(exist_ok=True, parents=True)
+        dest.write_bytes(sc_data)
+
+        action = subprocess.check_output(
+            [
+                "notify-send",
+                "-i",
+                "image-x-generic-symbolic",
+                "-h",
+                f"STRING:image-path:{dest}",
+                "-a",
+                "caelestia-cli",
+                "--action=open=Open",
+                "--action=save=Save",
+                "Screenshot taken",
+                f"Screenshot stored in {dest} and copied to clipboard",
+            ],
+            text=True,
+        ).strip()
+
+        if action == "open":
+            subprocess.Popen(["swappy", "-f", dest], start_new_session=True)
+        elif action == "save":
+            new_dest = (screenshots_dir / dest.name).with_suffix(".png")
+            new_dest.parent.mkdir(exist_ok=True, parents=True)
+            dest.rename(new_dest)
+            subprocess.run(["notify-send", "Screenshot saved", f"Saved to {new_dest}"])
diff --git a/src/caelestia/subcommands/toggle.py b/src/caelestia/subcommands/toggle.py
index fd49c30..b8ad11b 100644
--- a/src/caelestia/subcommands/toggle.py
+++ b/src/caelestia/subcommands/toggle.py
@@ -1,3 +1,4 @@
+import subprocess
 from argparse import Namespace
 
 from caelestia.utils import hypr
@@ -6,7 +7,6 @@ from caelestia.utils import hypr
 class Command:
     args: Namespace
     clients: list[dict[str, any]] = None
-    app2unit: str = None
 
     def __init__(self, args: Namespace) -> None:
         self.args = args
@@ -20,14 +20,6 @@ class Command:
 
         return self.clients
 
-    def get_app2unit(self) -> str:
-        if self.app2unit is None:
-            import shutil
-
-            self.app2unit = shutil.which("app2unit")
-
-        return self.app2unit
-
     def move_client(self, selector: callable, workspace: str) -> None:
         for client in self.get_clients():
             if selector(client):
@@ -37,9 +29,7 @@ class Command:
         exists = any(selector(client) for client in self.get_clients())
 
         if not exists:
-            import subprocess
-
-            subprocess.Popen([self.get_app2unit(), "--", *spawn], start_new_session=True)
+            subprocess.Popen(["app2unit", "--", *spawn], start_new_session=True)
 
         return not exists
 
diff --git a/src/caelestia/utils/paths.py b/src/caelestia/utils/paths.py
index 37aeeef..6a98dae 100644
--- a/src/caelestia/utils/paths.py
+++ b/src/caelestia/utils/paths.py
@@ -28,6 +28,9 @@ wallpaper_link_path = c_state_dir / "wallpaper/current"
 wallpaper_thumbnail_path = c_state_dir / "wallpaper/thumbnail.jpg"
 wallpapers_cache_dir = c_cache_dir / "wallpapers"
 
+screenshots_dir = Path.home() / "Pictures/Screenshots"
+screenshots_cache_dir = c_cache_dir / "screenshots"
+
 
 def compute_hash(path: Path | str) -> str:
     sha = hashlib.sha256()
-- 
cgit v1.2.3-freya


From b805f8d67725352817d248562683cb90bf314401 Mon Sep 17 00:00:00 2001
From: 2 * r + 2 * t <61896496+soramanew@users.noreply.github.com>
Date: Sat, 14 Jun 2025 02:11:10 +1000
Subject: feat: impl recording subcommand

---
 src/caelestia/parser.py             |   2 +-
 src/caelestia/subcommands/record.py | 113 +++++++++++++++++++++++++++++++++++-
 src/caelestia/utils/paths.py        |   4 ++
 3 files changed, 117 insertions(+), 2 deletions(-)

(limited to 'src/caelestia/parser.py')

diff --git a/src/caelestia/parser.py b/src/caelestia/parser.py
index 02ac3b9..6d0b552 100644
--- a/src/caelestia/parser.py
+++ b/src/caelestia/parser.py
@@ -68,7 +68,7 @@ def parse_args() -> (argparse.ArgumentParser, argparse.Namespace):
     # Create parser for record opts
     record_parser = command_parser.add_parser("record", help="start a screen recording")
     record_parser.set_defaults(cls=record.Command)
-    record_parser.add_argument("-r", "--region", action="store_true", help="record a region")
+    record_parser.add_argument("-r", "--region", nargs="?", const="slurp", help="record a region")
     record_parser.add_argument("-s", "--sound", action="store_true", help="record audio")
 
     # Create parser for clipboard opts
diff --git a/src/caelestia/subcommands/record.py b/src/caelestia/subcommands/record.py
index 37f9a2b..a4fa51d 100644
--- a/src/caelestia/subcommands/record.py
+++ b/src/caelestia/subcommands/record.py
@@ -1,4 +1,9 @@
+import subprocess
+import time
 from argparse import Namespace
+from datetime import datetime
+
+from caelestia.utils.paths import recording_notif_path, recording_path, recordings_dir
 
 
 class Command:
@@ -8,4 +13,110 @@ class Command:
         self.args = args
 
     def run(self) -> None:
-        pass
+        proc = subprocess.run(["pidof", "wl-screenrec"])
+        if proc.returncode == 0:
+            self.stop()
+        else:
+            self.start()
+
+    def start(self) -> None:
+        args = []
+
+        if self.args.region:
+            if self.args.region == "slurp":
+                region = subprocess.check_output(["slurp"], text=True)
+            else:
+                region = self.args.region
+            args += ["-g", region.strip()]
+
+        if self.args.sound:
+            sources = subprocess.check_output(["pactl", "list", "short", "sources"], text=True).splitlines()
+            for source in sources:
+                if "RUNNING" in source:
+                    args += ["--audio", "--audio-device", source.split()[1]]
+                    break
+            else:
+                raise ValueError("No audio source found")
+
+        proc = subprocess.Popen(
+            ["wl-screenrec", *args, "--codec", "hevc", "-f", recording_path],
+            stderr=subprocess.PIPE,
+            text=True,
+            start_new_session=True,
+        )
+
+        # Send notif if proc hasn't ended after a small delay
+        time.sleep(0.1)
+        if proc.poll() is None:
+            notif = subprocess.check_output(
+                ["notify-send", "-p", "-a", "caelestia-cli", "Recording started", "Recording..."], text=True
+            ).strip()
+            recording_notif_path.write_text(notif)
+        else:
+            subprocess.run(
+                [
+                    "notify-send",
+                    "-a",
+                    "caelestia-cli",
+                    "Recording failed",
+                    f"Recording failed to start: {proc.communicate()[1]}",
+                ]
+            )
+
+    def stop(self) -> None:
+        subprocess.run(["pkill", "wl-screenrec"])
+
+        # Move to recordings folder
+        new_path = recordings_dir / f"recording_{datetime.now().strftime('%Y%m%d_%H-%M-%S')}.mp4"
+        recording_path.rename(new_path)
+
+        # Close start notification
+        try:
+            notif = recording_notif_path.read_text()
+            subprocess.run(
+                [
+                    "gdbus",
+                    "call",
+                    "--session",
+                    "--dest=org.freedesktop.Notifications",
+                    "--object-path=/org/freedesktop/Notifications",
+                    "--method=org.freedesktop.Notifications.CloseNotification",
+                    notif,
+                ]
+            )
+        except IOError:
+            pass
+
+        action = subprocess.check_output(
+            [
+                "notify-send",
+                "-a",
+                "caelestia-cli",
+                "--action=watch=Watch",
+                "--action=open=Open",
+                "--action=delete=Delete",
+                "Recording stopped",
+                f"Recording saved in {new_path}",
+            ],
+            text=True,
+        ).strip()
+
+        if action == "watch":
+            subprocess.Popen(["app2unit", "-O", new_path], start_new_session=True)
+        elif action == "open":
+            p = subprocess.run(
+                [
+                    "dbus-send",
+                    "--session",
+                    "--dest=org.freedesktop.FileManager1",
+                    "--type=method_call",
+                    "/org/freedesktop/FileManager1",
+                    "org.freedesktop.FileManager1.ShowItems",
+                    f"array:string:file://{new_path}",
+                    "string:",
+                ]
+            )
+            if p.returncode != 0:
+                subprocess.Popen(["app2unit", "-O", new_path.parent], start_new_session=True)
+        elif action == "delete":
+            new_path.unlink()
diff --git a/src/caelestia/utils/paths.py b/src/caelestia/utils/paths.py
index 6a98dae..a4ef36f 100644
--- a/src/caelestia/utils/paths.py
+++ b/src/caelestia/utils/paths.py
@@ -31,6 +31,10 @@ wallpapers_cache_dir = c_cache_dir / "wallpapers"
 screenshots_dir = Path.home() / "Pictures/Screenshots"
 screenshots_cache_dir = c_cache_dir / "screenshots"
 
+recordings_dir = Path.home() / "Videos/Recordings"
+recording_path = c_state_dir / "record/recording.mp4"
+recording_notif_path = c_state_dir / "record/notifid.txt"
+
 
 def compute_hash(path: Path | str) -> str:
     sha = hashlib.sha256()
-- 
cgit v1.2.3-freya