making it aux

Author: codeafridi

.gitignore

@@ -1,2 +1,7 @@
 venv/
+.venv/
 __pycache__/
+*.pyc
+dist/
+build/
+*.deb

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Afridi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -2,277 +2,153 @@
 
 Turn your Copilot key into a customizable launcher on Linux.
 
-Press → menu → run anything instantly.
----
+Press the Copilot/F23 key, pick an action, and launch apps, websites, files, or system commands instantly.
 
-<img width="1488" height="656" alt="image" src="https://github.com/user-attachments/assets/2eac6d8d-46c6-4262-9c26-d98f351b4c49" />
+![KeyPilot screenshot](https://github.com/user-attachments/assets/2eac6d8d-46c6-4262-9c26-d98f351b4c49)
 
-here are the pdfs repo for CP - [My CP Notes Repo](https://github.com/codeafridi/Competitive-programming-notes)
+## Features
 
-##  Features
+- Opens a launcher menu from the Copilot/F23 key
+- Runs apps, websites, files, folders, and system commands
+- Configurable with simple JSON
+- Runs as a background user service
+- Supports `rofi-wayland`, `wofi`, `fuzzel`, and `rofi`
 
-- Press Copilot key → instantly open a menu  
-- Launch apps, browser, or system actions  
-- Fully customizable using a simple config file  
-- Runs in the background automatically  
-- Works across different Linux setups  
-
----
-
-##  Installation
+## Install From Source
 
 ```bash
-git clone https://github.com/yourname/keypilot
-cd keypilot
+git clone https://github.com/codeafridi/CopilotKey-Linux.git
+cd CopilotKey-Linux
 chmod +x install.sh
 ./install.sh
 ```
 
-Run the script as your normal user, not with `sudo`. It will ask for sudo only
-when it needs to install packages or update input-device permissions.
-
-The installer:
+Run the script as your normal user, not with `sudo`. It asks for `sudo` only when it needs to install system packages or update input-device permissions.
 
-- installs Python/system dependencies
-- creates a local `.venv`
-- installs Python packages into that `.venv`
-- installs a menu launcher (`rofi-wayland` when available, otherwise `rofi`)
-- adds your user to the `input` group
-- enables the `keypilot` user service
+After installation, log out and log back in. This is required so Linux applies the new `input` group permission to your desktop session.
 
-After installation, **log out and log back in** or reboot. This is required so
-Linux applies the new `input` group permission to your desktop session.
-
-Then start/restart KeyPilot:
+Then start KeyPilot:
 
 ```bash
 systemctl --user restart keypilot
 ```
 
----
+## Install From A Debian Package
 
-## Usage
+Build a local `.deb` package:
 
-Just press the **Copilot key**.
+```bash
+chmod +x packaging/deb/build-deb.sh
+packaging/deb/build-deb.sh 0.1.0
+```
+
+Install it on Ubuntu/Debian:
 
-A menu will appear where you can:
-- Open terminal  
-- Open browser  
-- Run custom actions  
+```bash
+sudo apt install ./dist/keypilot_0.1.0_all.deb
+```
 
-To check whether the background service is running:
+Then enable permissions and the user service:
 
 ```bash
-systemctl --user status keypilot
+sudo usermod -aG input "$USER"
 ```
 
-To watch logs while pressing the Copilot key:
+Log out and log back in, then run:
 
 ```bash
-journalctl --user -u keypilot -f
+mkdir -p ~/.config/keypilot
+cp /etc/keypilot/config.json ~/.config/keypilot/config.json
+systemctl --user daemon-reload
+systemctl --user enable --now keypilot
 ```
 
----
+## Usage
 
-## Customization
+Press the Copilot key. A menu appears with your configured actions.
 
-Edit `config.json` to change what the key does.
+Check whether the service is running:
 
-Example:
+```bash
+systemctl --user status keypilot
+```
 
-```json
-{
-  "KEY_F23": {
-    "type": "menu",
-    "options": [
-      { "label": "Terminal", "action": "terminal" },
-      { "label": "Browser", "action": "browser" }
-    ]
-  }
-}
+Watch logs while pressing the key:
+
+```bash
+journalctl --user -u keypilot -f
 ```
-## Adding More Menu Options
 
-You can add as many options as you want to the menu.
+## Configuration
 
-Just edit `config.json` and add more items inside the `options` list.
+Edit:
+
+```bash
+~/.config/keypilot/config.json
+```
+
+Example:
 
-### Example
 ```json
 {
   "KEY_F23": {
     "type": "menu",
     "options": [
-      { "label": "Terminal", "action": "terminal" },
-      { "label": "Browser", "action": "browser" },
-      { "label": "Shutdown", "action": "shutdown" },
-      { "label": "Files", "action": "files" },
-      { "label": "VS Code", "action": "code" }
+      {
+        "label": "Terminal",
+        "action": "terminal"
+      },
+      {
+        "label": "GitHub",
+        "command": ["xdg-open", "https://github.com"]
+      },
+      {
+        "label": "VS Code",
+        "command": ["code"]
+      }
     ]
   }
 }
 ```
-### Important
-
-If you add a new action in `config.json`, you also need to add it in the code.
-
-Open `keypilot.py` and find the `run_action()` function.
 
-### Actions Guide (Apps, Websites, Files, System Commands)
+Each menu option supports either:
 
-Every action is executed using:
-
-```python
-subprocess.Popen(["command", "arg1", "arg2"])
-```
-
----
-
-##  Quick Rules
-
-- **App** → `["app-name"]`
-- **Website** → `["xdg-open", "https://..."]`
-- **File/Folder** → `["xdg-open", "path"]`
-- **System command** → `["command", "argument"]`
-- **Search (optional)** → `["xdg-open", "https://google.com/search?q=..."]`
-
----
-
-## Common Examples
-
-| Category     | What you want to do         | Example code |
-|--------------|----------------------------|--------------|
-| App          | Open terminal              | `["gnome-terminal"]` |
-| App          | Open VS Code               | `["code"]` |
-| App          | Open Firefox               | `["firefox"]` |
-| App          | Open file manager          | `["nautilus"]` |
-| Website      | Open Google                | `["xdg-open", "https://google.com"]` |
-| Website      | Open YouTube               | `["xdg-open", "https://youtube.com"]` |
-| File/Folder  | Open current folder        | `["xdg-open", "."]` |
-| File/Folder  | Open Downloads             | `["xdg-open", "~/Downloads"]` |
-| File         | Open a PDF                 | `["xdg-open", "file.pdf"]` |
-| System       | Shutdown                   | `["systemctl", "poweroff"]` |
-| System       | Restart                    | `["systemctl", "reboot"]` |
-| System       | Lock screen                | `["loginctl", "lock-session"]` |
-| System       | Logout                     | `["gnome-session-quit", "--logout"]` |
-| Search       | Google search              | `["xdg-open", "https://google.com/search?q=linux"]` |
-| Custom       | Run script                 | `["bash", "script.sh"]` |
-| Custom       | Python script              | `["python3", "file.py"]` |
-
----
-
-## Example in `run_action()`
-
-```python
-def run_action(action):
-    if action == "terminal":
-        subprocess.Popen(["gnome-terminal"])
-    elif action == "browser":
-        subprocess.Popen(["xdg-open", "https://google.com"])
-    elif action == "shutdown":
-        subprocess.Popen(["systemctl", "poweroff"])
-    elif action == "code":
-        subprocess.Popen(["code"])
-```
+- `action`: a built-in KeyPilot action
+- `command`: a command array, for example `["xdg-open", "https://example.com"]`
 
----
+Built-in actions:
 
-##  Important
+- `terminal`
+- `browser`
+- `shutdown`
 
-- Always use `["command", "arg"]` format  
-- Do NOT write commands as a single string  
-- Use `xdg-open` for anything that should open with default apps  
-
----
-
-Thats it. you can launch anything.
-After changing the service file or reinstalling dependencies, run:
-
-```bash
-./install.sh
-systemctl --user restart keypilot
-```
-
----
+Use `command` for everything else. KeyPilot does not run commands through a shell, so write each command and argument as a separate JSON string.
 
 ## Requirements
 
 - Linux
 - Python 3
-- `python3-venv`
-- one supported menu launcher:
-  - `rofi-wayland` recommended for Wayland
+- `evdev`
+- `xdg-open`
+- One menu launcher:
+  - `rofi-wayland` recommended for GNOME/Wayland
   - `wofi`
   - `fuzzel`
-  - `rofi` for X11
-
----
-
-## Notes
-
-- Uses low-level input (`/dev/input`) → permissions handled in install script  
-- The installer uses a local `.venv`, so it avoids Python's
-  `externally-managed-environment` / PEP 668 error.
-- KeyPilot tries menu launchers in this order: `rofi-wayland`, `wofi`,
-  `fuzzel`, then `rofi`.
-- On GNOME Wayland, classic `/usr/bin/rofi` may crash. Install `rofi-wayland`
-  or `wofi`, then restart the service.
-
----
-
-## Troubleshooting
-
-### Service says "No suitable input device found"
-
-Check your active groups:
-
-```bash
-id -nG | grep -w input
-```
-
-If nothing prints, log out completely and log back in, or reboot. Then run:
+  - `rofi`
 
-```bash
-systemctl --user reset-failed keypilot
-systemctl --user restart keypilot
-journalctl --user -u keypilot -n 30 --no-pager
-```
-
-When it works, the logs should contain something like:
-
-```text
-[KeyPilot] Using F23 device: /dev/input/event3 (...)
-[KeyPilot] Listening...
-```
-
-### Ubuntu reports that rofi crashed
-
-If you see an Ubuntu crash dialog for `/usr/bin/rofi`, install a Wayland-friendly
-launcher:
+## Permissions
 
-```bash
-sudo apt install rofi-wayland
-```
-
-If that package is not available:
-
-```bash
-sudo apt install wofi
-```
-
-Then restart KeyPilot:
-
-```bash
-systemctl --user restart keypilot
-```
+KeyPilot reads low-level keyboard events from `/dev/input`. On Ubuntu, the installer adds your user to the `input` group so the user service can read the Copilot/F23 key.
 
----
+This is powerful access. Only install KeyPilot from source you trust.
 
-## Why this exists
+## Packaging Roadmap
 
-On Linux, the Copilot key is useless.
+- `.deb` package for Ubuntu/Debian
+- AUR package for Arch Linux
+- Snap package for Ubuntu App Center
+- Optional GNOME extension later, if deeper GNOME integration becomes useful
 
-KeyPilot turns it into something actually useful.
+## License
 
-Works on X11 and can work on Wayland when a Wayland-friendly menu launcher is
-installed.
+MIT