HackaProfile 0.1.0__tar.gz

hackaprofile-0.1.0/HackaProfile.egg-info/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: HackaProfile
+Version: 0.1.0
+Summary: A simple tool to automatically update Slack user profile based on their Hackatime/Wakatime heartbeat!
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: annotated-doc==0.0.4
+Requires-Dist: blinker==1.9.0
+Requires-Dist: certifi==2026.6.17
+Requires-Dist: charset-normalizer==3.4.7
+Requires-Dist: click==8.4.1
+Requires-Dist: dotenv==0.9.9
+Requires-Dist: Flask==3.1.3
+Requires-Dist: idna==3.18
+Requires-Dist: itsdangerous==2.2.0
+Requires-Dist: jaraco.classes==3.4.0
+Requires-Dist: jaraco.context==6.1.2
+Requires-Dist: jaraco.functools==4.5.0
+Requires-Dist: Jinja2==3.1.6
+Requires-Dist: keyring==25.7.0
+Requires-Dist: markdown-it-py==4.2.0
+Requires-Dist: MarkupSafe==3.0.3
+Requires-Dist: mdurl==0.1.2
+Requires-Dist: more-itertools==11.1.0
+Requires-Dist: prompt_toolkit==3.0.52
+Requires-Dist: psutil==7.2.2
+Requires-Dist: Pygments==2.20.0
+Requires-Dist: pyperclip==1.11.0
+Requires-Dist: python-dotenv==1.2.2
+Requires-Dist: questionary==2.1.1
+Requires-Dist: requests==2.34.2
+Requires-Dist: rich==15.0.0
+Requires-Dist: shellingham==1.5.4
+Requires-Dist: typer==0.26.7
+Requires-Dist: urllib3==2.7.0
+Requires-Dist: wcwidth==0.8.1
+Requires-Dist: Werkzeug==3.1.8
+Requires-Dist: platformdirs==4.10.0
+
+# HackaProfile
+<img src="./assets/icon.png" width=30% alt="HackaProfile logo"></img>
+
+### A simple tool to automatically update Slack (more platforms *SOON*) user profile based on their Hackatime/Wakatime heartbeat!
+
+## Features
+- FULLY local (no data leaves your device except for the API calls to update profile)
+- FULLY customizable (see the Place holder variables section)
+- More features #TODO ~~(I don't wanna write README.md >:3)~~
+
+## installation
+> [!TIP]
+> One line install does not work yet!
+### MacOS
+`brew install hackaprofile`
+### Linux
+Debian/Ubuntu:
+`apt install hackaprofile`
+
+## Placeholder Variables
+A key feature of HackaProfile is that it allows you to customise your profile however you like (just like how you would change it on Slack/other platforms) BUT it **also allows you to use dynamic values** (i.e. Placeholder variables).
+
+Example
+`I am typing {{language}} in {{project}} project` becomes `I am typing Python in HackaProfile project`
+
+-`{{id}}` Some sort of Hackatime id, might be unique?
+- `{{created_at}}` When was the Hackatime data last fetched
+- `{{time}}` Current time in Unix Timestamp
+- `{{category}}`: Category of the Hackatime action
+    - communicating
+    - ai coding
+    - coding
+    - writing docs
+- `{{project}}` Hackatime project name
+- `{{language}}` Shows the current language that that you are working on
+- `{{editor}}` Current IDE/Editor
+- `{{operating_system}}` The current OS (N.B for MacOS, it shows `darwin`)
+- `{{entity}}` Path to the file workng on
+- `{{machine}}` Current machine's hostname
+

hackaprofile-0.1.0/HackaProfile.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+HackaProfile.egg-info/PKG-INFO
+HackaProfile.egg-info/SOURCES.txt
+HackaProfile.egg-info/dependency_links.txt
+HackaProfile.egg-info/entry_points.txt
+HackaProfile.egg-info/requires.txt
+HackaProfile.egg-info/top_level.txt
+src/__init__.py
+src/agent.py
+src/backend.py
+src/frontend.py
+src/hackatimeOA.py
+src/slackOA.py
+src/configTemplate/agent.pid
+src/configTemplate/hackaprofile.conf
+src/configTemplate/hackatime.hackaprofile.conf
+src/configTemplate/slack.hackaprofile.conf
+src/logTemplate/agent.log

hackaprofile-0.1.0/HackaProfile.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hackaprofile-0.1.0/HackaProfile.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+hackaprofile = src.frontend:app

hackaprofile-0.1.0/HackaProfile.egg-info/requires.txt

@@ -0,0 +1,32 @@
+annotated-doc==0.0.4
+blinker==1.9.0
+certifi==2026.6.17
+charset-normalizer==3.4.7
+click==8.4.1
+dotenv==0.9.9
+Flask==3.1.3
+idna==3.18
+itsdangerous==2.2.0
+jaraco.classes==3.4.0
+jaraco.context==6.1.2
+jaraco.functools==4.5.0
+Jinja2==3.1.6
+keyring==25.7.0
+markdown-it-py==4.2.0
+MarkupSafe==3.0.3
+mdurl==0.1.2
+more-itertools==11.1.0
+prompt_toolkit==3.0.52
+psutil==7.2.2
+Pygments==2.20.0
+pyperclip==1.11.0
+python-dotenv==1.2.2
+questionary==2.1.1
+requests==2.34.2
+rich==15.0.0
+shellingham==1.5.4
+typer==0.26.7
+urllib3==2.7.0
+wcwidth==0.8.1
+Werkzeug==3.1.8
+platformdirs==4.10.0

hackaprofile-0.1.0/HackaProfile.egg-info/top_level.txt

@@ -0,0 +1 @@
+src

hackaprofile-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: HackaProfile
+Version: 0.1.0
+Summary: A simple tool to automatically update Slack user profile based on their Hackatime/Wakatime heartbeat!
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: annotated-doc==0.0.4
+Requires-Dist: blinker==1.9.0
+Requires-Dist: certifi==2026.6.17
+Requires-Dist: charset-normalizer==3.4.7
+Requires-Dist: click==8.4.1
+Requires-Dist: dotenv==0.9.9
+Requires-Dist: Flask==3.1.3
+Requires-Dist: idna==3.18
+Requires-Dist: itsdangerous==2.2.0
+Requires-Dist: jaraco.classes==3.4.0
+Requires-Dist: jaraco.context==6.1.2
+Requires-Dist: jaraco.functools==4.5.0
+Requires-Dist: Jinja2==3.1.6
+Requires-Dist: keyring==25.7.0
+Requires-Dist: markdown-it-py==4.2.0
+Requires-Dist: MarkupSafe==3.0.3
+Requires-Dist: mdurl==0.1.2
+Requires-Dist: more-itertools==11.1.0
+Requires-Dist: prompt_toolkit==3.0.52
+Requires-Dist: psutil==7.2.2
+Requires-Dist: Pygments==2.20.0
+Requires-Dist: pyperclip==1.11.0
+Requires-Dist: python-dotenv==1.2.2
+Requires-Dist: questionary==2.1.1
+Requires-Dist: requests==2.34.2
+Requires-Dist: rich==15.0.0
+Requires-Dist: shellingham==1.5.4
+Requires-Dist: typer==0.26.7
+Requires-Dist: urllib3==2.7.0
+Requires-Dist: wcwidth==0.8.1
+Requires-Dist: Werkzeug==3.1.8
+Requires-Dist: platformdirs==4.10.0
+
+# HackaProfile
+<img src="./assets/icon.png" width=30% alt="HackaProfile logo"></img>
+
+### A simple tool to automatically update Slack (more platforms *SOON*) user profile based on their Hackatime/Wakatime heartbeat!
+
+## Features
+- FULLY local (no data leaves your device except for the API calls to update profile)
+- FULLY customizable (see the Place holder variables section)
+- More features #TODO ~~(I don't wanna write README.md >:3)~~
+
+## installation
+> [!TIP]
+> One line install does not work yet!
+### MacOS
+`brew install hackaprofile`
+### Linux
+Debian/Ubuntu:
+`apt install hackaprofile`
+
+## Placeholder Variables
+A key feature of HackaProfile is that it allows you to customise your profile however you like (just like how you would change it on Slack/other platforms) BUT it **also allows you to use dynamic values** (i.e. Placeholder variables).
+
+Example
+`I am typing {{language}} in {{project}} project` becomes `I am typing Python in HackaProfile project`
+
+-`{{id}}` Some sort of Hackatime id, might be unique?
+- `{{created_at}}` When was the Hackatime data last fetched
+- `{{time}}` Current time in Unix Timestamp
+- `{{category}}`: Category of the Hackatime action
+    - communicating
+    - ai coding
+    - coding
+    - writing docs
+- `{{project}}` Hackatime project name
+- `{{language}}` Shows the current language that that you are working on
+- `{{editor}}` Current IDE/Editor
+- `{{operating_system}}` The current OS (N.B for MacOS, it shows `darwin`)
+- `{{entity}}` Path to the file workng on
+- `{{machine}}` Current machine's hostname
+

hackaprofile-0.1.0/README.md

@@ -0,0 +1,40 @@
+# HackaProfile
+<img src="./assets/icon.png" width=30% alt="HackaProfile logo"></img>
+
+### A simple tool to automatically update Slack (more platforms *SOON*) user profile based on their Hackatime/Wakatime heartbeat!
+
+## Features
+- FULLY local (no data leaves your device except for the API calls to update profile)
+- FULLY customizable (see the Place holder variables section)
+- More features #TODO ~~(I don't wanna write README.md >:3)~~
+
+## installation
+> [!TIP]
+> One line install does not work yet!
+### MacOS
+`brew install hackaprofile`
+### Linux
+Debian/Ubuntu:
+`apt install hackaprofile`
+
+## Placeholder Variables
+A key feature of HackaProfile is that it allows you to customise your profile however you like (just like how you would change it on Slack/other platforms) BUT it **also allows you to use dynamic values** (i.e. Placeholder variables).
+
+Example
+`I am typing {{language}} in {{project}} project` becomes `I am typing Python in HackaProfile project`
+
+-`{{id}}` Some sort of Hackatime id, might be unique?
+- `{{created_at}}` When was the Hackatime data last fetched
+- `{{time}}` Current time in Unix Timestamp
+- `{{category}}`: Category of the Hackatime action
+    - communicating
+    - ai coding
+    - coding
+    - writing docs
+- `{{project}}` Hackatime project name
+- `{{language}}` Shows the current language that that you are working on
+- `{{editor}}` Current IDE/Editor
+- `{{operating_system}}` The current OS (N.B for MacOS, it shows `darwin`)
+- `{{entity}}` Path to the file workng on
+- `{{machine}}` Current machine's hostname
+

hackaprofile-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "HackaProfile"
+version = "0.1.0"
+description = "A simple tool to automatically update Slack user profile based on their Hackatime/Wakatime heartbeat!"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "annotated-doc==0.0.4",
+    "blinker==1.9.0",
+    "certifi==2026.6.17",
+    "charset-normalizer==3.4.7",
+    "click==8.4.1",
+    "dotenv==0.9.9",
+    "Flask==3.1.3",
+    "idna==3.18",
+    "itsdangerous==2.2.0",
+    "jaraco.classes==3.4.0",
+    "jaraco.context==6.1.2",
+    "jaraco.functools==4.5.0",
+    "Jinja2==3.1.6",
+    "keyring==25.7.0",
+    "markdown-it-py==4.2.0",
+    "MarkupSafe==3.0.3",
+    "mdurl==0.1.2",
+    "more-itertools==11.1.0",
+    "prompt_toolkit==3.0.52",
+    "psutil==7.2.2",
+    "Pygments==2.20.0",
+    "pyperclip==1.11.0",
+    "python-dotenv==1.2.2",
+    "questionary==2.1.1",
+    "requests==2.34.2",
+    "rich==15.0.0",
+    "shellingham==1.5.4",
+    "typer==0.26.7",
+    "urllib3==2.7.0",
+    "wcwidth==0.8.1",
+    "Werkzeug==3.1.8",
+    "platformdirs==4.10.0",
+]
+
+[project.scripts]
+hackaprofile = "src.frontend:app"
+
+[tool.setuptools]
+packages = ["src"]
+
+[tool.setuptools.package-data]
+src = ["configTemplate/*", "logTemplate/*"]

hackaprofile-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

hackaprofile-0.1.0/src/__init__.py

@@ -0,0 +1,3 @@
+"""HackaProfile - Automatically update Slack profile based on Hackatime/Wakatime heartbeat"""
+
+__version__ = "0.0.1"

hackaprofile-0.1.0/src/agent.py

@@ -0,0 +1,106 @@
+import time
+try:
+    from . import backend
+except ImportError:
+    import backend
+import dotenv
+import os
+from pathlib import Path
+import platformdirs
+
+hackatime = backend.hackatime()
+slack = backend.slack()
+
+
+active_services = ["slack"]
+interval = 20
+HOME = Path.home()
+CONFIG_DIR = Path(platformdirs.user_config_dir("hackaprofile"))
+LOG_DIR = Path(platformdirs.user_log_dir("hackaprofile"))
+
+
+# langauge = ""
+
+pid = os.getpid()
+with open(CONFIG_DIR / "agent.pid", "w") as f:
+    f.write(str(pid))
+    f.close()
+
+def clean_value(value: str) -> str:
+    """
+    Makes the values clean for slack (Value passed for `name` contained unallowed special characters)
+    """
+    return value.replace("<", "").replace(">", "")
+
+def parse_config(config: dict, map):
+    parsed_config = {}
+    for _, field in enumerate(config):
+        key = field
+        template: str = config[field]
+        # Replace {{key}} placeholders directly from the map.
+        for map_key, map_value in map.items():
+            template = template.replace(map_key, str(map_value))
+        try:
+            parsed_value = clean_value(template.format_map(map))
+            
+            # if the config field is empty, don't append it
+            if parsed_value != "":
+                parsed_config[key] = parsed_value
+        except KeyError:
+            pass
+            
+        # print(parsed)
+        
+    return parsed_config
+
+while True:
+    json = hackatime.fetch_hb()
+    
+    # for _, field in enumerate(json):
+    #     key = field
+    #     value = json.get(field, "")
+
+    # project = 
+    
+    
+    map = {
+        "{{id}}": json.get("id", ""),
+        "{{created_at}}": json.get("created_at", ""),
+        "{{time}}": json.get("time", ""),
+        "{{category}}": json.get("category", ""),
+        "{{project}}": json.get("project", ""),
+        "{{language}}": json.get("language", ""),
+        "{{editor}}": json.get("editor", ""),
+        "{{operating_system}}": json.get("operating_system", ""),
+        "{{machine}}": json.get("machine", ""),
+        "{{entity}}": json.get("entity", "")
+    }
+    
+    
+    
+    print(f'Language: {map["{{language}}"]}')
+    print(json)
+    
+    if "slack" in active_services:
+        print(slack.fetch_config())
+        config = parse_config(slack.fetch_config(), map)
+        print(config)
+        
+        res = slack.set_profile(config)
+        print(res)
+        # for _, field in enumerate(slack_config):
+        #     print((field, slack_config[field]))
+            
+            
+        # slack.set_profile(
+        #     profile={
+        #         "status_text": "test status text",
+        #         "status_emoji": ":67:",
+        #         "status_expiration": 0
+        # })
+    print("---")
+    time.sleep(interval)
+    
+    
+    
+#  

hackaprofile-0.1.0/src/backend.py

@@ -0,0 +1,171 @@
+try:
+    from . import hackatimeOA
+    from . import slackOA
+except ImportError:
+    import hackatimeOA
+    import slackOA
+import keyring
+import requests
+import dotenv
+from pathlib import Path
+import platformdirs
+
+service_name = "HackaProfile"
+CONFIG_DIR = Path(platformdirs.user_config_dir("hackaprofile"))
+LOG_DIR = Path(platformdirs.user_log_dir("hackaprofile"))
+
+# config = dotenv.dotenv_values("../config/.conf")
+
+
+class hackatime():
+    def __init__(self) -> None:
+        self.hb_url = "https://hackatime.hackclub.com/api/v1/authenticated/heartbeats/latest"
+        self.username = "hackatime_token"
+        self.config_path = CONFIG_DIR / "hackatime.hackaprofile.conf"
+        # self.client_id = self.load_config()["client_id"]
+    # Authorize hackatime
+    def authorize(self) -> tuple:
+        token = hackatimeOA.authenticate()
+        # If token is given:
+        if type(token) == str and token:
+            self.store_token(token)
+            return (True, token)
+        else:
+            return (False, token)
+    
+    def revoke(self):
+        url = "https://hackatime.hackclub.com/oauth/revoke"
+        print(self.fetch_config()["client_id"])
+        headers = {
+        "Authorization": f"Bearer {self.get_token()}"
+        }
+        data = {
+            "token": self.get_token(),
+            "client_id": self.fetch_config()["client_id"],
+        }
+        
+        # dataJson = json.dumps(data)
+        # print(dataJson)
+        return requests.post(url=url, data=data).json()
+
+    def get_token(self) -> str:
+        token = keyring.get_password(service_name, self.username)
+        if type(token) != str:
+            token = ""
+        return token
+    
+    def store_token(self, token: str) -> None:
+        keyring.set_password(service_name, self.username, token)
+    
+    def fetch_hb(self):
+        url = self.hb_url
+        headers = {
+            "Authorization": f"Bearer {self.get_token()}"
+        }
+        try:
+            res = requests.get(url=url, headers=headers)
+            json = res.json()
+        except:
+            json = {"ok": False}
+        return json
+    
+    def fetch_config(self) -> dict:
+        return dotenv.dotenv_values(self.config_path)
+    
+    def status(self):
+        json = self.fetch_hb()
+        # print(json)
+        
+        # Hackatime does not return ok if its ok. Weird...
+        ok = json.get("ok", True)
+        if ok == False:
+            error = json.get("error", "")
+        else:
+            error = ""
+        return {"ok": ok, "error": error}
+    def load_config(self) -> dict:
+        return dotenv.dotenv_values(self.config_path)
+
+
+class slack():
+    def __init__(self) -> None:
+        self.base_url = "https://slack.com/api"
+        self.username = "slack_token"
+        self.config_path = CONFIG_DIR / "slack.hackaprofile.conf"
+        # self.client_id = self.load_config()["client_id"]
+    # Authorize hackatime
+    def authorize(self) -> tuple:
+        token = slackOA.authenticate()
+        # If token is given:
+        if type(token) == str and token:
+            self.store_token(token)
+            return (True, token)
+        else:
+            return (False, token)
+            
+    def get_token(self) -> str:
+        token = keyring.get_password(service_name, self.username)
+        if type(token) != str:
+            token = ""
+        return token
+    
+    def store_token(self, token: str) -> None:
+        keyring.set_password(service_name, self.username, token)
+        
+    def set_profile(self, profile: dict) -> dict:
+        url = f"{self.base_url}/users.profile.set"
+        headers = {
+        "Authorization": f"Bearer {self.get_token()}"
+        }
+        data = {
+            "profile": profile
+        }
+        
+        # dataJson = json.dumps(data)
+        # print(dataJson)
+        return requests.post(url=url, headers=headers, json=data).json()
+
+    def get_profile(self):
+        url = f"{self.base_url}/users.profile.get"
+        headers = {
+        "Authorization": f"Bearer {self.get_token()}"
+        }
+        
+        # dataJson = json.dumps(data)
+        # print(dataJson)
+        return requests.get(url=url, headers=headers).json()
+    
+    # Get the field id <-> label pairs
+    def get_team_profile(self):
+        url = f"{self.base_url}/team.profile.get"
+        headers = {
+        "Authorization": f"Bearer {self.get_token()}"
+        }
+        
+        # dataJson = json.dumps(data)
+        # print(dataJson)
+        return requests.get(url=url, headers=headers).json()
+    
+    def fetch_config(self) -> dict:
+        return dotenv.dotenv_values(self.config_path)
+    
+    def status(self):
+        pass
+        # json = self.fetch_hb()
+        # # print(json)
+        
+        # # Hackatime does not return ok if its ok. Weird...
+        # ok = json.get("ok", True)
+        # if ok == False:
+        #     error = json.get("error", "")
+        # else:
+        #     error = ""
+        # return {"ok": ok, "error": error}
+        
+        
+    def load_config(self) -> dict:
+        return dotenv.dotenv_values(self.config_path)
+
+platfroms = {
+    "slack": slack,
+}

hackaprofile-0.1.0/src/configTemplate/hackaprofile.conf

@@ -0,0 +1,3 @@
+# WARNING: DO NOT CHANGE UNLESS YOU KNOW WHAT YOU ARE DOING
+hackatime_client_id = "WAlWRi9-IfFv2F88Iv6O75iZD7MoSVpCQtwrCj8xvrY"
+slack_client_id = "2210535565.11339190985360" 

hackaprofile-0.1.0/src/configTemplate/hackatime.hackaprofile.conf

@@ -0,0 +1,2 @@
+# Don't change this plz :3 (it will break...)
+client_id = "WAlWRi9-IfFv2F88Iv6O75iZD7MoSVpCQtwrCj8xvrY"

hackaprofile-0.1.0/src/configTemplate/slack.hackaprofile.conf

@@ -0,0 +1,11 @@
+# Don't change this plz (it will break...)
+client_id = "2210535565.11339190985360"
+
+title = 
+phone = 
+real_name =
+display_name = 
+status_text = 
+status_emoji = 
+
+# Check README.md

hackaprofile-0.1.0/src/frontend.py

@@ -0,0 +1,360 @@
+import time
+from rich import print as rprint
+from rich.panel import Panel
+from rich.console import Console, Group
+from rich.text import Text
+from rich.pretty import Pretty, pprint
+from rich.prompt import Confirm
+from rich.table import Table
+from rich import box
+from rich.live import Live
+from rich.highlighter import Highlighter
+# from rich.terminal_theme import MONOKAI
+
+import typer
+from typing import Annotated
+
+try:
+    from . import backend
+except ImportError:
+    import backend
+
+import questionary
+
+import os
+import shutil
+from pathlib import Path
+import dotenv
+import pyperclip
+
+import subprocess as sp
+
+import sys
+import psutil
+import signal
+import platformdirs
+
+console = Console()
+
+app = typer.Typer(no_args_is_help=True)
+hackatime = backend.hackatime()
+slack = backend.slack()
+
+CONFIG_DIR = Path(platformdirs.user_config_dir("hackaprofile"))
+LOG_DIR = Path(platformdirs.user_log_dir("hackaprofile"))
+
+@app.callback()
+def callback():
+    """
+    Useful tool to automatically update online profiles based on Hackatime status
+    """
+    
+# Auto completion
+def complete_platform(incomplete: str) -> list:
+    valid_names = ["HackaTime", "Slack"]
+    completion = []
+    for name in valid_names:
+        if name.startswith(incomplete):
+            completion.append(name)
+    return completion
+
+@app.command()
+def status():
+    """
+    View the status of HackaProfile
+    """
+    parsed_hackatime_status = {}
+    parsed_slack_status = {}
+    
+    with console.status("Fetching status...", spinner="dots"):
+        hackatime_status: dict = hackatime.fetch_hb()
+        
+        temp = slack.get_profile()
+        # rprint(temp)
+        try:
+            slack_status: dict = temp["profile"]
+        except KeyError:
+            # If there is an error
+            slack_status: dict = temp
+        # rprint(slack_status)
+        
+    if hackatime_status.get("ok", True) == False:
+        parsed_hackatime_status["Authorization"] = "❌ Unauthorized"
+    else:
+        parsed_hackatime_status["Authorization"] = "[bold green]✓[/bold green] Authorized"
+        parsed_hackatime_status["Current Language"] = hackatime_status.get("language", "Unknown")
+        parsed_hackatime_status["Current Project"] = hackatime_status.get("project", "Unknown")
+        
+    # print(slack_status)
+    if slack_status.get("ok") == False:
+        parsed_slack_status["Authorization"] = f"❌ {slack_status.get("error", "Unknown error")}"
+    else:
+        parsed_slack_status["Authorization"] = "[bold green]✓[/bold green] Authorized"
+        parsed_slack_status["Display Name"] = slack_status.get("display_name", "Unknown")
+        parsed_slack_status["Status Text"] = slack_status.get("status_text", "Unknown")
+        parsed_slack_status["Status Emoji"] = slack_status.get("status_emoji", "Unknown")
+        
+    
+    hackatime_table = Table("Field", "Value", title="Hackatime", box=box.ROUNDED, expand=True)
+    slack_table = Table("Field", "Value", title="Slack", box=box.ROUNDED, expand=True)
+    
+    for _, field in enumerate(parsed_hackatime_status):
+        key = field
+        value = parsed_hackatime_status[field]
+        hackatime_table.add_row(key, value)
+        
+    for _, field in enumerate(parsed_slack_status):
+        key = field
+        value = parsed_slack_status[field]
+        slack_table.add_row(key, value)
+    
+    grid = Table.grid(expand=True, padding=10)
+    grid.add_column()
+    grid.add_column(justify="right")
+    grid.add_row(hackatime_table, slack_table)
+    rprint(
+        "",
+        grid
+    )
+    
+
+# [bold green]✓[/bold green]
+def authorizeHA():
+    ok, hatoken = hackatime.authorize()
+    # If token is given:
+    if ok:
+        rprint("[bold green]✓[/bold green] Hackatime authorized!")
+        return hatoken
+    else:
+        rprint(f"[bold red]err: {str(hatoken)}")
+        hatoken = authorizeHA()
+        
+    return hatoken
+
+@app.command()
+def setup(force: Annotated[bool, typer.Option("--force")] = False):
+    """
+    Guided setup of HackaProfile
+    """
+    console.clear()
+    # console.rule("HackaProfile")
+    rprint(Panel(Text("Welcome to HackaProfile\nyou will be guided on an easy setup of the tool!", justify="center")))
+    console.rule()
+    # rprint(force)
+    
+    # Copy log files
+    try:
+        # Allow overwrite if set to force
+        shutil.copytree(Path(__file__).resolve().parent / "logTemplate", LOG_DIR, dirs_exist_ok=force)
+        rprint("[bold green]✓[/bold green] Log file setup done!")
+    except FileExistsError:
+        rprint("[bold green]✓[/bold green] Log file already exists!")
+    except Exception as e:
+        rprint(f"❌ Failed to setup log files: {e}")
+        
+    # Copy config files
+    try:
+        # Allow overwrite if set to force
+        shutil.copytree(Path(__file__).resolve().parent / "configTemplate", CONFIG_DIR, dirs_exist_ok=force)
+        rprint("[bold green]✓[/bold green] Config file setup done!")
+    except FileExistsError:
+        rprint("[bold green]✓[/bold green] Config file already exists!")
+    except Exception as e:
+        rprint(f"❌ Failed to setup config files: {e}")
+        
+    
+    # If no token stored
+    if force or not hackatime.status()["ok"]:
+        # hackatimeConfirm = Confirm.ask("[bold cyan]Do you want to authorize Hackatime (This will redirect you to OAuth page)", default=True)
+        hackatimeConfirm  = questionary.confirm("Do you want to authorize Hackatime (This will redirect you to OAuth page)").ask()
+        if hackatimeConfirm:
+            with console.status("Authorizing Hackatime", spinner="dots"):
+                ok, hackatime_token = hackatime.authorize()
+                
+            if ok:
+                rprint("[bold green]✓[/bold green] Hackatime authorized!")
+                
+            else :
+                rprint(f"[bold red]err: {str(hackatime_token)}")    
+        else:
+            rprint("[bold red]err: HackaProfile could not function without Hackatime.")
+            typer.Abort()
+    # If already stored
+    else:
+        rprint("[bold green]✓[/bold green] Hackatime already authorized!\n")
+        
+    platforms = questionary.checkbox(
+        message="Please choose the platforms you want to link to",
+        choices=[
+            "Slack",
+            "Github"
+        ]
+    ).ask()
+    
+    # Authorize the platforms
+    
+    for platform in platforms:
+        # print("test")
+        cls = backend.platfroms.get(platform.lower())
+        if cls:
+            instance = cls()
+            with console.status(f"Authorizing {platform}", spinner="dots"):
+                ok, platform_token = instance.authorize()
+            if ok:
+                rprint(f"[bold green]✓[/bold green] {platform} authorized!")
+                
+            else:
+                rprint(f"[bold red]err: {str(platform_token)}")
+            
+        else:
+            rprint("[bold red]err: Platform unsupported")
+        
+        
+    rprint("[bold green]✓[/bold green] Setup complete!\n\n1.Run [bold green]hackaprofile config \\[platform name][/bold green] to configure\n2.Run [bold green]hackaprofile start[/bold green] to start updating your profile automatically!")
+        
+class placeholderHighlighter(Highlighter):
+    def highlight(self, text) -> None:
+        text.highlight_regex(r"\{\{.*?\}\}", "bold yellow")
+        
+@app.command()
+def config(platform: Annotated[str, typer.Argument]):
+    """
+    Shows a structured preview of the config files for each of the platforms
+    """
+    
+    table = Table(
+        "Field",
+        "Value",
+        title="Preview Slack",
+        box=box.ROUNDED,
+        expand=True,
+    )
+    
+    hlt = placeholderHighlighter()
+    slack_config_keys = list(slack.load_config().keys())
+    slack_config_values = list(slack.load_config().values())
+    
+    for i in range(len(slack_config_keys)):
+        field = slack_config_keys[i]
+        value = slack_config_values[i]
+        if not value:
+            value = "Not set"
+        table.add_row(field, hlt(value))
+            
+            
+    rprint(table)
+    option = questionary.select(
+        "What do you want to do?",
+        choices = [
+            "Edit",
+            "Exit"
+        ]
+    ).ask()
+    
+    if option == "Exit":
+        typer.Exit()
+    elif option == "Edit":
+        path = str(CONFIG_DIR/ f"{platform}.hackaprofile.conf")
+        rprint(f"\n[bold green]Open[/bold green] {path} [bold green]in your preferred editor!")
+    
+        cbConfirm = questionary.confirm(
+            "Do you want to copy path to clipboard?",
+            default=False
+        ).ask()
+        if cbConfirm:
+            pyperclip.copy(path)
+            rprint("[bold green]✓[/bold green] Copied!")
+    
+    # with Live(table, refresh_per_second=4):
+    #     console.clear()Path(__file__).resolve().parent.parent / "config" / f"{platform}.hackaprofile.conf"
+    #     while True:
+    #         table.add_row("Status", "I love coding")
+    #         # table.add_row("Status")
+    #         time.sleep(0.5)
+        
+@app.command(deprecated=True)
+def auth(platform: Annotated[str, typer.Option(prompt=False, help="Which platform you want to authenticate", autocompletion=complete_platform)] = ""):
+    """
+    Using OAuth to bind HackaProfile to your account
+    """
+    
+    rprint(f"Please use [bold green]hackaprofile setup[/bold green] and select the platforms you want to authorize, use [bold green]--force[/bold green] to re-auth Hackatime")
+
+@app.command()
+def revoke(platform: str, all: Annotated[bool, typer.Option("--all")] = False):
+    
+    # TODO
+    if all:
+        pass
+    else:
+        if platform == "hackatime":
+            rprint(hackatime.revoke())
+
+
+def get_agent_pid() -> int:
+    """
+    Retruns PID of the agent process based on agent.pid
+    """
+
+    with open(CONFIG_DIR / "agent.pid", "r") as f:
+        pid = f.readline()
+        f.close()
+    return int(pid)
+
+def is_agent_alive(pid: int) -> bool:
+    return psutil.pid_exists(pid)
+
+@app.command()
+def start():
+    log = open(LOG_DIR / "agent.log", "a")
+    error = "Unknown error"
+    try:
+        sp.Popen(
+            [sys.executable, "-u", Path(__file__).resolve().parent / "agent.py"],
+            stdout=log,
+            stderr=sp.STDOUT,
+            stdin=sp.DEVNULL,
+            start_new_session=True
+            
+        )
+    except Exception as e:
+        error = e
+    time.sleep(0.5)
+    pid = get_agent_pid()
+    if is_agent_alive(pid):
+        rprint(f"[bold green]✓[/bold green] Started background worker!")
+    else:
+        rprint(f"❌ Worker not started. {error}")
+    
+@app.command()
+def stop():
+    pid = get_agent_pid()
+    error = ""
+    
+    try:
+        os.kill(pid, signal.SIGTERM)
+    except Exception as e:
+        error = " " + str(e)
+
+    time.sleep(0.5)
+    if not is_agent_alive(pid) and not error:
+        rprint(f"[bold green]✓[/bold green] Stopped background worker!")
+    else:
+        rprint(f"❌ Worker not stopped{error}. Retry or manually kill process {pid}")
+
+@app.command()
+def restart():
+    stop()
+    start()
+    
+@app.command()
+def debug():
+    """
+    Development purpose only: Uhh, don't worry about it...
+    """
+    print(CONFIG_DIR)
+    print(LOG_DIR)
+
+    
+if __name__ == "__main__":
+    app()

hackaprofile-0.1.0/src/hackatimeOA.py

@@ -0,0 +1,116 @@
+from flask import Flask, request
+import requests
+import secrets
+import hashlib
+import base64
+import webbrowser
+from werkzeug.serving import make_server
+import threading
+import time
+import logging
+import dotenv
+from pathlib import Path
+import platformdirs
+
+log = logging.getLogger('werkzeug')
+
+log.setLevel(logging.ERROR)
+
+stateRNG = secrets.token_urlsafe(32)
+baseUrl = "https://hackatime.hackclub.com/oauth/authorize"
+exchangeBaseUrl = "https://hackatime.hackclub.com/oauth/token"
+redirection_uri = "http://localhost:32767/auth/hackatime/callback"
+
+CONFIG_DIR = Path(platformdirs.user_config_dir("hackaprofile"))
+LOG_DIR = Path(platformdirs.user_log_dir("hackaprofile"))
+
+# print(client_id)
+token = ""
+code_verifier = ""
+client_id = ""
+
+token_event = threading.Event()
+# Redirect to the auth page
+def redirection(state):
+    # print("debug")
+    global code_verifier, client_id
+    
+    # Just an unique id, not secret lol
+    client_id = dotenv.dotenv_values(CONFIG_DIR / "hackatime.hackaprofile.conf")["client_id"]
+
+
+    code_verifier = secrets.token_urlsafe(664)
+    digest = hashlib.sha256(code_verifier.encode()).digest()
+    code_challenge = base64.urlsafe_b64encode(digest).decode().rstrip('=')
+    args = {
+        "client_id": client_id,
+        "redirect_uri": redirection_uri,
+        "response_type": "code",
+        "state": state,
+        "code_challenge": code_challenge,
+        "code_challenge_method": "S256",
+        "state": state,
+    }
+    url = f"{baseUrl}/?client_id={args['client_id']}&redirect_uri={args["redirect_uri"]}&response_type=code&state={args["state"]}&code_challenge={args["code_challenge"]}&code_challenge_method={args["code_challenge_method"]}&state={args["state"]}"
+    
+    webbrowser.open(url)
+
+
+# Exchange API key
+def exchange(code: str):
+    global token_event
+    url = exchangeBaseUrl
+    data = {
+        "client_id": client_id,
+        "code": code,
+        "redirect_uri": redirection_uri,
+        "grant_type": "authorization_code",
+        "code_verifier": code_verifier,
+        
+    }
+    res = requests.post(url=url, data=data)
+    json = res.json()
+    token_event.set()
+    if not json.get("error"):
+        token = json.get("access_token")
+        # print(token)
+        return token
+    else:
+        return {"error": json.get("error")}
+# Handle callback
+app = Flask(__name__)
+
+@app.route("/auth/hackatime/callback")
+def hackatimeCallback():
+    global token
+    code = request.args.get("code")
+    error = request.args.get("error")
+    state2 = request.args.get("state")
+    # print(code)
+    
+    if not error and code and state2 == stateRNG:
+        token = exchange(code)
+        # print(token)
+        return "<p>Authorization completed, you can close this tab now.</p>"
+    else:
+        return "<p>You have denied authorization, or an error has occured.</p><p>If you did not deny authorization, please close this tab and submit a issue on Github</p>"
+    
+
+def authenticate():
+    redirection(stateRNG)
+    server = make_server("127.0.0.1", 32767, app)
+    thread = threading.Thread(target=server.serve_forever)
+    thread.start()
+    
+    token_event.wait(timeout=120)
+        
+    
+    server.shutdown()
+    thread.join()
+    return token
+
+
+
+# Debug
+if __name__ == "__main__":
+    authenticate()

hackaprofile-0.1.0/src/slackOA.py

@@ -0,0 +1,114 @@
+from flask import Flask, request
+import requests
+import secrets
+import hashlib
+import base64
+import webbrowser
+from werkzeug.serving import make_server
+import threading
+import time
+import logging
+import dotenv
+from pathlib import Path
+import platformdirs
+
+log = logging.getLogger('werkzeug')
+
+log.setLevel(logging.ERROR)
+
+stateRNG = secrets.token_urlsafe(32)
+baseUrl = "https://slack.com/oauth/v2/authorize"
+exchangeBaseUrl = "https://slack.com/api/oauth.v2.access"
+redirection_uri = "http://localhost:32767/auth/slack/callback"
+CONFIG_DIR = Path(platformdirs.user_config_dir("hackaprofile"))
+LOG_DIR = Path(platformdirs.user_log_dir("hackaprofile"))
+
+token = ""
+code_verifier = ""
+
+token_event = threading.Event()
+client_id = ""
+# Redirect to the auth page
+def redirection(state):
+    # print("debug")
+    global code_verifier, client_id
+    
+    # Just an unique id, not secret lol
+    client_id = dotenv.dotenv_values(CONFIG_DIR / "slack.hackaprofile.conf")["client_id"]
+
+
+    code_verifier = secrets.token_urlsafe(664)
+    digest = hashlib.sha256(code_verifier.encode()).digest()
+    code_challenge = base64.urlsafe_b64encode(digest).decode().rstrip('=')
+    args = {
+        "client_id": client_id,
+        "redirect_uri": redirection_uri,
+        "response_type": "code",
+        "state": state,
+        "code_challenge": code_challenge,
+        "code_challenge_method": "S256",
+        "scope": "",
+        "user_scope": "users.profile:read,users.profile:write"
+    }
+    url = f"{baseUrl}/?client_id={args['client_id']}&redirect_uri={args["redirect_uri"]}&scope={args["scope"]}&user_scope={args["user_scope"]}&state={args["state"]}&code_challenge={args["code_challenge"]}&code_challenge_method={args["code_challenge_method"]}"
+    
+    webbrowser.open(url)
+
+
+# Exchange API key
+def exchange(code: str):
+    global token_event
+    
+    url = exchangeBaseUrl
+    data = {
+        "client_id": client_id,
+        "code": code,
+        "redirect_uri": redirection_uri,
+        "grant_type": "authorization_code",
+        "code_verifier": code_verifier,
+        
+    }
+    res = requests.post(url=url, data=data)
+    json = res.json()
+    token_event.set()
+    if json.get("ok") == True:
+        token = json.get("authed_user", {}).get("access_token", None)
+        # print(token)
+        return token
+    else:
+        return {"error": json.get("error")}
+# Handle callback
+app = Flask(__name__)
+
+@app.route("/auth/slack/callback")
+def hackatimeCallback():
+    global token
+    code = request.args.get("code")
+    error = request.args.get("error")
+    state2 = request.args.get("state")
+    # print(code)
+    if not error and code and state2 == stateRNG:
+        token = exchange(code)
+        # print(token)
+        return "<p>Authorization completed, you can close this tab now.</p>"
+    else:
+        return "<p>You have denied authorization, or an error has occured.</p><p>If you did not deny authorization, please close this tab and submit a issue on Github</p>"
+    
+
+def authenticate():
+    redirection(stateRNG)
+    server = make_server("127.0.0.1", 32767, app)
+    thread = threading.Thread(target=server.serve_forever)
+    thread.start()
+        
+    token_event.wait(timeout=120)
+    
+    server.shutdown()
+    thread.join()
+    return token
+
+
+
+# Debug
+if __name__ == "__main__":
+    authenticate()