🔧 - Changes the prefix and suffix values for various launcher actions in the constants.py file.

This commit is contained in:
sankalp committed 2025-06-20 23:04:18 +05:45
1 parent 0360227ed4
commit 63334f6569
25 files changed
+1395 -184

No files matched your search

+51
View File
@@ -5,12 +5,15 @@ Prevents system from going idle for a specified duration.
import subprocess
from typing import List
from threading import Timer
import gi
import utils.icons as icons
from fabric.utils import get_relative_path
from fabric.utils.helpers import exec_shell_command_async
from modules.launcher.plugin_base import PluginBase
from modules.launcher.result import Result
import config.data as data
gi.require_version("Gtk", "3.0")
@@ -57,11 +60,59 @@ class CaffeinePlugin(PluginBase):
stderr=subprocess.DEVNULL,
start_new_session=True, # Run in a new session to prevent hanging
)
# Send notification based on duration
if duration.lower() == "off":
# Deactivation notification
exec_shell_command_async(
f"notify-send '☕ Caffeine' 'Deactivated' -a '{data.APP_NAME_CAP}' -e"
)
else:
# Activation notification with duration
duration_text = self.durations.get(duration, duration)
exec_shell_command_async(
f"notify-send '☕ Caffeine' 'Activated for {duration_text}' -a '{data.APP_NAME_CAP}' -e"
)
# Schedule expiration notification for timed durations
if duration.lower() not in ["on", "off"]:
self._schedule_expiration_notification(duration, duration_text)
except Exception as e:
print(f"Error starting inhibit script: {e}")
return action
def _parse_duration_to_seconds(self, duration_str: str) -> int:
"""Parse duration string into seconds. Same logic as inhibit.py"""
try:
if duration_str.lower() in ['on', 'off']:
return 0
elif duration_str.endswith('h'):
return int(float(duration_str[:-1]) * 3600)
elif duration_str.endswith('m'):
return int(float(duration_str[:-1]) * 60)
elif duration_str.endswith('s'):
return int(float(duration_str[:-1]))
else:
return int(duration_str)
except ValueError:
return 0
def _schedule_expiration_notification(self, duration: str, duration_text: str):
"""Schedule a notification for when the caffeine effect expires."""
seconds = self._parse_duration_to_seconds(duration)
if seconds > 0:
def send_expiration_notification():
exec_shell_command_async(
f"notify-send '☕ Caffeine' 'Expired after {duration_text}' -a '{data.APP_NAME_CAP}' -e"
)
# Schedule the notification
timer = Timer(seconds, send_expiration_notification)
timer.daemon = True # Don't prevent program exit
timer.start()
def _is_valid_duration(self, query: str) -> bool:
"""Check if the query is a valid duration format."""
if query in self.durations:
+135 -35
View File
@@ -1,12 +1,16 @@
"""
Clipboard plugin using cliphist for clipboard history management.
Optimized for performance with caching, threading, and lazy loading.
"""
import os
import subprocess
import sys
import tempfile
from typing import List, Dict
import threading
import time
from typing import List, Dict, Optional
from concurrent.futures import ThreadPoolExecutor, as_completed
from modules.launcher.plugin_base import PluginBase
from modules.launcher.result import Result
from gi.repository import GdkPixbuf, GLib
@@ -19,41 +23,82 @@ class ClipboardPlugin(PluginBase):
self.display_name = "Clipboard History"
self.description = "Search and manage clipboard history using cliphist"
# Performance settings
self.max_results = 20
self.cache_ttl = 30 # Cache clipboard items for 30 seconds
self.image_cache_ttl = 300 # Cache images for 5 minutes
# Initialize cache and temp directory
self.tmp_dir = tempfile.mkdtemp(prefix="cliphist-")
self.image_cache: Dict[str, GdkPixbuf.Pixbuf] = {}
self.clipboard_items = []
self.clipboard_items_cache: List[str] = []
self.cache_timestamp = 0
self.image_cache_timestamps: Dict[str, float] = {}
# Threading
self.executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix="clipboard")
self.cache_lock = threading.Lock()
# State tracking
self._loading = False
self._pending_updates = False
def initialize(self):
self.set_triggers(["clip", "clip "])
"""Initialize the plugin."""
self.set_triggers(["clip", "clip "])
try:
subprocess.run(["cliphist", "list"], capture_output=True, check=True)
subprocess.run(["cliphist", "list"], capture_output=True, check=True, timeout=5)
except (subprocess.SubprocessError, FileNotFoundError):
raise RuntimeError("cliphist is not installed or not working properly")
# Pre-warm cache in background
self.executor.submit(self._load_clipboard_items_cached)
def cleanup(self):
"""Cleanup the plugin."""
try:
# Shutdown executor
if hasattr(self, 'executor'):
self.executor.shutdown(wait=False)
# Clean up temp files
if os.path.exists(self.tmp_dir):
import shutil
shutil.rmtree(self.tmp_dir)
self.image_cache.clear()
# Clear caches
with self.cache_lock:
self.image_cache.clear()
self.clipboard_items_cache.clear()
self.image_cache_timestamps.clear()
except Exception as e:
print(f"Error cleaning up temporary files: {e}", file=sys.stderr)
def _load_clipboard_items(self) -> List[str]:
"""Load clipboard items from cliphist."""
def _load_clipboard_items_cached(self) -> List[str]:
"""Load clipboard items from cliphist with caching."""
current_time = time.time()
# Check if cache is still valid
with self.cache_lock:
if (self.clipboard_items_cache and
current_time - self.cache_timestamp < self.cache_ttl):
return self.clipboard_items_cache.copy()
# Load fresh data
try:
result = subprocess.run(
["cliphist", "list"], capture_output=True, check=True
["cliphist", "list"], capture_output=True, check=True, timeout=5
)
stdout_str = result.stdout.decode("utf-8", errors="replace")
lines = stdout_str.strip().split("\n")
return [line for line in lines if line and "<meta http-equiv" not in line]
items = [line for line in lines if line and "<meta http-equiv" not in line]
# Update cache
with self.cache_lock:
self.clipboard_items_cache = items
self.cache_timestamp = current_time
return items
except subprocess.CalledProcessError as e:
print(f"Error loading clipboard history: {e}", file=sys.stderr)
return []
@@ -61,6 +106,10 @@ class ClipboardPlugin(PluginBase):
print(f"Unexpected error: {e}", file=sys.stderr)
return []
def _load_clipboard_items(self) -> List[str]:
"""Load clipboard items (legacy method for compatibility)."""
return self._load_clipboard_items_cached()
def _create_pixbuf_from_bytes(
self, image_data: bytes, max_size: int = 100
) -> GdkPixbuf.Pixbuf:
@@ -98,25 +147,37 @@ class ClipboardPlugin(PluginBase):
return content[:37] + "..."
return content
def _load_image_preview_async(self, item_id: str) -> GdkPixbuf.Pixbuf:
"""Load image preview asynchronously."""
if item_id in self.image_cache:
return self.image_cache[item_id]
def _load_image_preview_cached(self, item_id: str) -> Optional[GdkPixbuf.Pixbuf]:
"""Load image preview with caching and timeout."""
current_time = time.time()
# Check cache first
with self.cache_lock:
if (item_id in self.image_cache and
item_id in self.image_cache_timestamps and
current_time - self.image_cache_timestamps[item_id] < self.image_cache_ttl):
return self.image_cache[item_id]
try:
result = subprocess.run(
["cliphist", "decode", item_id], capture_output=True, check=True
["cliphist", "decode", item_id], capture_output=True, check=True, timeout=3
)
pixbuf = self._create_pixbuf_from_bytes(result.stdout)
if pixbuf:
self.image_cache[item_id] = pixbuf
with self.cache_lock:
self.image_cache[item_id] = pixbuf
self.image_cache_timestamps[item_id] = current_time
return pixbuf
except Exception as e:
print(f"Error loading image preview: {e}", file=sys.stderr)
return None
def _load_image_preview_async(self, item_id: str) -> Optional[GdkPixbuf.Pixbuf]:
"""Load image preview (legacy method for compatibility)."""
return self._load_image_preview_cached(item_id)
def query(self, query_string: str) -> List[Result]:
"""Search clipboard history using cliphist."""
"""Search clipboard history using cliphist with optimized performance."""
results = []
# Handle query string
@@ -124,46 +185,82 @@ class ClipboardPlugin(PluginBase):
query_string = "" # Show all items
try:
# Load clipboard items
self.clipboard_items = self._load_clipboard_items()
# Load clipboard items from cache
clipboard_items = self._load_clipboard_items_cached()
# Filter items based on query
# Early exit if no items
if not clipboard_items:
return results
# Filter items based on query with early termination
filtered_items = []
for item in self.clipboard_items:
query_lower = query_string.lower() if query_string else ""
for item in clipboard_items:
# Stop if we have enough results
if len(filtered_items) >= self.max_results:
break
parts = item.split("\t", 1)
content = parts[1] if len(parts) > 1 else item
if not query_string or query_string.lower() in content.lower():
# Fast filtering
if not query_lower or query_lower in content.lower():
filtered_items.append(item)
# Process all items without batching
for item in filtered_items:
# Process items with lazy image loading
for i, item in enumerate(filtered_items):
# Limit total results
if len(results) >= self.max_results:
break
parts = item.split("\t", 1)
item_id = parts[0] if len(parts) > 1 else "0"
item_id = parts[0] if len(parts) > 1 else str(i)
content = parts[1] if len(parts) > 1 else item
# Handle image content
# Handle image content with lazy loading
if self._is_image_data(content):
pixbuf = self._load_image_preview_async(item_id)
if pixbuf:
# Check if image is already cached
cached_pixbuf = None
with self.cache_lock:
cached_pixbuf = self.image_cache.get(item_id)
if cached_pixbuf:
# Use cached image
result = Result(
title="Image from clipboard",
subtitle="Click to copy image to clipboard",
description="Image content",
icon=pixbuf,
icon=cached_pixbuf,
relevance=1.0,
plugin_name=self.name,
action=lambda id=item_id: self._copy_to_clipboard(id),
data={"bypass_max_results": True},
)
results.append(result)
continue
else:
# Show placeholder and load image in background
result = Result(
title="Image from clipboard",
subtitle="Loading preview...",
description="Image content",
icon_name="image-x-generic",
relevance=1.0,
plugin_name=self.name,
action=lambda id=item_id: self._copy_to_clipboard(id),
data={"bypass_max_results": True},
)
# Load image in background (don't wait for it)
self.executor.submit(self._load_image_preview_cached, item_id)
results.append(result)
continue
# Handle text content
display_text = self._get_text_preview(content)
result = Result(
title=display_text,
subtitle="Text from clipboard",
description=content,
description=content if len(content) <= 100 else content[:97] + "...",
icon_name="edit-paste",
relevance=1.0,
plugin_name=self.name,
@@ -188,19 +285,22 @@ class ClipboardPlugin(PluginBase):
return results
def _copy_to_clipboard(self, entry_id: str):
"""Copy entry to clipboard using cliphist."""
"""Copy entry to clipboard using cliphist with timeout."""
try:
result = subprocess.run(
["cliphist", "decode", entry_id], capture_output=True, check=True
["cliphist", "decode", entry_id], capture_output=True, check=True, timeout=5
)
# Use wl-copy for Wayland or xclip for X11
try:
subprocess.run(["wl-copy"], input=result.stdout, check=True)
subprocess.run(["wl-copy"], input=result.stdout, check=True, timeout=3)
except subprocess.SubprocessError:
subprocess.run(
["xclip", "-selection", "clipboard"],
input=result.stdout,
check=True,
timeout=3
)
except subprocess.SubprocessError as e:
print(f"Error copying to clipboard: {e}", file=sys.stderr)
except subprocess.TimeoutExpired as e:
print(f"Timeout copying to clipboard: {e}", file=sys.stderr)
+808
View File
@@ -0,0 +1,808 @@
"""
OTP Manager plugin for the launcher.
Provides TOTP (Time-based One-Time Password) management.
"""
import json
import subprocess
import time
import threading
from typing import List, Dict, Optional
from pathlib import Path
import base64
from fabric.utils import get_relative_path
from modules.launcher.plugin_base import PluginBase
from modules.launcher.result import Result
import utils.icons as icons
try:
import pyotp
PYOTP_AVAILABLE = True
except ImportError:
PYOTP_AVAILABLE = False
class OTPPlugin(PluginBase):
"""Plugin for managing TOTP (Time-based One-Time Password) codes."""
def __init__(self):
super().__init__()
self.display_name = "OTP Manager"
self.description = "Manage TOTP codes and 2FA authentication"
self.secrets_file = Path(get_relative_path("../../../config/otp_accounts.json"))
self.secrets: Dict[str, Dict] = {}
self.last_update = 0
# Threading for auto-refresh
self.refresh_thread = None
self.stop_refresh = threading.Event()
def initialize(self):
"""Initialize the OTP plugin."""
if not PYOTP_AVAILABLE:
raise RuntimeError("pyotp is required for OTP functionality. Install with: pip install pyotp")
self.set_triggers(["otp", "2fa", "totp", "auth"])
self._load_secrets()
self._ensure_config_file()
self._start_refresh_thread()
def cleanup(self):
"""Cleanup the OTP plugin."""
if self.refresh_thread and self.refresh_thread.is_alive():
self.stop_refresh.set()
self.refresh_thread.join(timeout=1)
def _load_secrets(self):
"""Load secrets from JSON file."""
try:
if self.secrets_file.exists():
with open(self.secrets_file, 'r', encoding='utf-8') as f:
self.secrets = json.load(f)
else:
self.secrets = {}
except Exception as e:
print(f"Error loading OTP secrets: {e}")
self.secrets = {}
def _save_secrets(self):
"""Save secrets to JSON file."""
try:
self.secrets_file.parent.mkdir(parents=True, exist_ok=True)
with open(self.secrets_file, 'w', encoding='utf-8') as f:
json.dump(self.secrets, f, indent=2)
except Exception as e:
print(f"Error saving OTP secrets: {e}")
subprocess.run([
"notify-send", "OTP Manager Error",
f"Failed to save config: {str(e)}",
"-i", "dialog-error"
], check=False)
def _ensure_config_file(self):
"""Ensure the config file exists."""
if not self.secrets_file.exists():
self.secrets_file.parent.mkdir(parents=True, exist_ok=True)
with open(self.secrets_file, 'w', encoding='utf-8') as f:
json.dump({}, f, indent=2)
def _start_refresh_thread(self):
"""Start background thread for auto-refreshing tokens."""
def refresh_loop():
while not self.stop_refresh.wait(1):
current_time = time.time()
if current_time - self.last_update >= 1:
self.last_update = current_time
if self.secrets:
try:
self._selective_force_refresh()
except Exception:
pass
self.refresh_thread = threading.Thread(target=refresh_loop, daemon=True)
self.refresh_thread.start()
def _selective_force_refresh(self):
"""Update time display in existing OTP result items."""
try:
from gi.repository import GLib
import gc
def do_update():
try:
for obj in gc.get_objects():
if (hasattr(obj, '__class__') and
obj.__class__.__name__ == 'Launcher' and
hasattr(obj, 'results_box') and
hasattr(obj, 'visible') and obj.visible and
hasattr(obj, 'results') and obj.results):
has_otp_results = any(
result.data and result.data.get("type") == "totp"
for result in obj.results
if hasattr(result, 'data') and result.data
)
if has_otp_results:
self._update_existing_result_labels(obj.results_box)
return False
except Exception:
pass
return False
GLib.idle_add(do_update)
except Exception:
pass
def _update_existing_result_labels(self, results_box):
"""Update subtitle labels in existing ResultItem widgets."""
try:
time_display = self._get_time_remaining_with_blink()
for child in results_box.get_children():
if (hasattr(child, '__class__') and child.__class__.__name__ == 'ResultItem' and
hasattr(child, 'result') and hasattr(child.result, 'data') and
child.result.data and child.result.data.get("type") == "totp"):
self._update_result_item_content(child, time_display)
except Exception as e:
print(f"Error updating result labels: {e}")
def _update_result_item_content(self, result_item, time_display):
"""Update both the title (OTP code) and subtitle (time display) of a specific ResultItem."""
try:
account_name = result_item.result.data.get("account", "")
if not account_name or account_name not in self.secrets:
return
account_data = self.secrets[account_name]
secret = account_data.get("secret", "")
issuer = account_data.get("issuer", "")
display_name = f"{issuer} - {account_name}" if issuer else account_name
current_totp_code = self._generate_totp(secret)
if not current_totp_code:
return
old_code = result_item.result.data.get("code", "")
if current_totp_code != old_code:
result_item.result.data["code"] = current_totp_code
self._find_and_update_title_label(result_item, current_totp_code)
result_item.result.action = lambda code=current_totp_code: self._copy_to_clipboard(code)
new_subtitle_markup = f"{display_name} • {time_display} remaining"
self._find_and_update_subtitle_label(result_item, new_subtitle_markup)
except Exception as e:
print(f"Error updating result item: {e}")
def _find_and_update_title_label(self, result_item, new_title):
"""Find the title label widget and update its text."""
def find_title_label(widget):
if hasattr(widget, 'get_name') and widget.get_name() == "result-item-title":
return widget
if hasattr(widget, 'get_children'):
for child in widget.get_children():
found = find_title_label(child)
if found:
return found
return None
title_label = find_title_label(result_item)
if title_label and hasattr(title_label, 'set_label'):
title_label.set_label(new_title)
def _find_and_update_subtitle_label(self, result_item, new_markup):
"""Find the subtitle label widget and update its markup."""
def find_subtitle_label(widget):
if hasattr(widget, 'get_name') and widget.get_name() == "result-item-subtitle":
return widget
if hasattr(widget, 'get_children'):
for child in widget.get_children():
found = find_subtitle_label(child)
if found:
return found
return None
subtitle_label = find_subtitle_label(result_item)
if subtitle_label and hasattr(subtitle_label, 'set_markup'):
subtitle_label.set_markup(new_markup)
def _copy_to_clipboard(self, text: str):
"""Copy text to clipboard."""
try:
try:
subprocess.run(["wl-copy"], input=text.encode(), check=True)
except subprocess.SubprocessError:
subprocess.run(["xclip", "-selection", "clipboard"], input=text.encode(), check=True)
except Exception as e:
print(f"Failed to copy to clipboard: {e}")
def _trigger_refresh(self):
"""Trigger launcher refresh to return to default OTP view."""
try:
from gi.repository import GLib
# Use a small delay to ensure the action completes first
def trigger_refresh():
try:
# Try to access the launcher through the fabric Application
from fabric import Application
app = Application.get_default()
if app and hasattr(app, 'launcher'):
launcher = app.launcher
if launcher and hasattr(launcher, 'search_entry'):
# Clear the search entry and set it to just "otp "
launcher.search_entry.set_text("otp ")
# Position cursor at the end
launcher.search_entry.set_position(-1)
# Trigger the search to show default OTP view
if hasattr(launcher, '_perform_search'):
launcher._perform_search("otp ")
return False
# Fallback: try to find launcher instance through other means
import gc
for obj in gc.get_objects():
if hasattr(obj, '__class__') and obj.__class__.__name__ == 'Launcher':
if hasattr(obj, 'search_entry') and hasattr(obj, '_perform_search'):
obj.search_entry.set_text("otp ")
obj.search_entry.set_position(-1)
obj._perform_search("otp ")
return False
except Exception as e:
print(f"Error forcing launcher refresh: {e}")
return False # Don't repeat
# Use a small delay to ensure the action completes first
GLib.timeout_add(50, trigger_refresh)
except Exception as e:
print(f"Could not trigger refresh: {e}")
def _remove_account_and_refresh(self, account_name: str):
"""Remove an account and trigger refresh to return to default OTP view."""
try:
if account_name in self.secrets:
# Get account info for notification
account_data = self.secrets[account_name]
issuer = account_data.get("issuer", "")
display_name = f"{issuer} - {account_name}" if issuer else account_name
# Remove the account
del self.secrets[account_name]
self._save_secrets()
# Show notification
subprocess.run([
"notify-send", "OTP Manager",
f"Removed '{display_name}' successfully",
"-i", "dialog-information"
], check=False)
# Trigger refresh to return to default OTP view
self._trigger_refresh()
else:
# Account not found
subprocess.run([
"notify-send", "OTP Manager Error",
f"Account '{account_name}' not found",
"-i", "dialog-error"
], check=False)
except Exception as e:
print(f"Error removing account {account_name}: {e}")
subprocess.run([
"notify-send", "OTP Manager Error",
f"Failed to remove account: {str(e)}",
"-i", "dialog-error"
], check=False)
def _generate_totp(self, secret: str) -> Optional[str]:
"""Generate TOTP code from secret."""
try:
return pyotp.TOTP(secret).now()
except Exception as e:
print(f"Error generating TOTP: {e}")
return None
def _get_time_remaining(self) -> int:
"""Get seconds remaining until next token refresh."""
return 30 - (int(time.time()) % 30)
def _get_time_remaining_with_blink(self) -> str:
"""Get time remaining with blinking effect."""
time_remaining = self._get_time_remaining()
current_second = int(time.time())
should_blink = (current_second % 2 == 0)
if should_blink:
return f"<span alpha='30%'>{time_remaining}s</span>"
else:
return f"{time_remaining}s"
def query(self, query_string: str) -> List[Result]:
"""Process OTP queries."""
query = query_string.strip()
if not query:
return self._list_otp_codes()
query_lower = query.lower()
if query_lower.startswith("add "):
add_content = query[4:].strip()
# Handle both formats: with ``` and without ```
if "```" in add_content:
# Old format: add account```secret```
parts = add_content.split("```", 1)
if len(parts) == 2:
account_name = parts[0].strip()
secret_or_uri = parts[1].strip()
return self._handle_direct_add(account_name, secret_or_uri)
elif " " in add_content:
# New format: add account secret
parts = add_content.split(" ", 1)
if len(parts) == 2:
account_name = parts[0].strip()
secret_or_uri = parts[1].strip()
return self._handle_direct_add(account_name, secret_or_uri)
return self._handle_add_command(add_content)
elif query_lower == "remove" or query_lower.startswith("remove "):
# Handle both "remove" and "remove accountname"
if query_lower == "remove":
remove_content = ""
else:
remove_content = query[7:].strip()
return self._handle_remove_command(remove_content)
else:
return self._search_accounts(query)
def _handle_direct_add(self, account_name: str, secret_or_uri: str) -> List[Result]:
"""Handle direct addition of OTP account."""
if not account_name or not secret_or_uri:
return [Result(
title="Invalid format",
subtitle="Usage: add <account_name> <secret> or add <account_name>```<secret>```",
icon_markup=icons.question,
action=lambda: None,
relevance=1.0,
plugin_name=self.display_name,
data={"type": "help", "keep_launcher_open": True}
)]
# Debug info
print(f"OTP Debug: Adding account '{account_name}' with secret/URI: '{secret_or_uri[:20]}...'")
try:
if secret_or_uri.startswith("otpauth://"):
print("OTP Debug: Processing as otpauth URI")
return self._handle_otpauth_uri(account_name, secret_or_uri)
else:
print("OTP Debug: Processing as Base32 secret")
return self._handle_base32_secret(account_name, secret_or_uri)
except Exception as e:
print(f"OTP Debug: Error in _handle_direct_add: {e}")
return [Result(
title="Error adding account",
subtitle=f"Debug: {str(e)}",
icon_markup=icons.cancel,
action=lambda: None,
relevance=0.5,
plugin_name=self.display_name,
data={"type": "error", "keep_launcher_open": True}
)]
def _list_otp_codes(self) -> List[Result]:
"""List all OTP codes with current tokens."""
results = []
if not self.secrets:
results.append(Result(
title="No OTP accounts configured",
subtitle="Use 'add <account> <secret>' to add your first account",
icon_markup=icons.key,
action=lambda: None,
relevance=1.0,
plugin_name=self.display_name,
data={"type": "empty", "keep_launcher_open": True}
))
results.append(Result(
title="Available commands:",
subtitle="add <account> <secret> | remove <account>",
icon_markup=icons.info,
action=lambda: None,
relevance=0.9,
plugin_name=self.display_name,
data={"type": "help", "keep_launcher_open": True}
))
return results
time_display = self._get_time_remaining_with_blink()
for account_name, account_data in self.secrets.items():
secret = account_data.get("secret", "")
issuer = account_data.get("issuer", "")
totp_code = self._generate_totp(secret)
if totp_code:
display_name = f"{issuer} - {account_name}" if issuer else account_name
results.append(Result(
title=f"{totp_code}",
subtitle_markup=f"{display_name} • {time_display} remaining",
icon_markup=icons.key,
action=lambda code=totp_code: self._copy_to_clipboard(code),
relevance=1.0,
plugin_name=self.display_name,
data={"type": "totp", "account": account_name, "code": totp_code}
# Note: No keep_launcher_open flag - launcher will close after copying
))
else:
results.append(Result(
title=f"Error: {account_name}",
subtitle="Invalid secret or configuration",
icon_markup=icons.cancel,
action=lambda: None,
relevance=0.5,
plugin_name=self.display_name,
data={"type": "error", "account": account_name, "keep_launcher_open": True}
))
return results
def _search_accounts(self, query: str) -> List[Result]:
"""Search accounts by name or issuer."""
results = []
query_lower = query.lower()
for account_name, account_data in self.secrets.items():
issuer = account_data.get("issuer", "").lower()
account_lower = account_name.lower()
if query_lower in account_lower or query_lower in issuer:
secret = account_data.get("secret", "")
totp_code = self._generate_totp(secret)
if totp_code:
display_name = f"{account_data.get('issuer', '')} - {account_name}" if account_data.get('issuer') else account_name
time_display = self._get_time_remaining_with_blink()
results.append(Result(
title=f"{totp_code}",
subtitle_markup=f"{display_name} • {time_display} remaining",
icon_markup=icons.key,
action=lambda code=totp_code: self._copy_to_clipboard(code),
relevance=1.0,
plugin_name=self.display_name,
data={"type": "totp", "account": account_name, "code": totp_code}
# Note: No keep_launcher_open flag - launcher will close after copying
))
if not results:
results.append(Result(
title=f"No accounts found for '{query}'",
subtitle="Use 'add <account> <secret>' to create new account",
icon_markup=icons.magnifier,
action=lambda: None,
relevance=0.5,
plugin_name=self.display_name,
data={"type": "no_results", "keep_launcher_open": True}
))
results.append(Result(
title="Available commands:",
subtitle="add <account> <secret> | remove <account>",
icon_markup=icons.info,
action=lambda: None,
relevance=0.4,
plugin_name=self.display_name,
data={"type": "help", "keep_launcher_open": True}
))
return results
def _handle_add_command(self, account_name: str) -> List[Result]:
"""Handle manual addition of OTP secret."""
if not account_name:
return [Result(
title="Enter account name",
subtitle="Usage: add <account_name> <secret>",
icon_markup=icons.question,
action=lambda: None,
relevance=1.0,
plugin_name=self.display_name,
data={"type": "help", "keep_launcher_open": True}
)]
return [
Result(
title=f"To add '{account_name}':",
subtitle=f"Type: add {account_name} <secret>",
icon_markup=icons.bulb,
action=lambda: None,
relevance=1.0,
plugin_name=self.display_name,
data={"type": "instruction", "account": account_name, "keep_launcher_open": True}
),
Result(
title="Base32 Secret Format:",
subtitle="Example: add gmail JBSWY3DPEHPK3PXP",
icon_markup=icons.info,
action=lambda: None,
relevance=0.9,
plugin_name=self.display_name,
data={"type": "help", "keep_launcher_open": True}
),
Result(
title="otpauth URI Format:",
subtitle="Example: add github otpauth://totp/GitHub:user?secret=JBSWY3DPEHPK3PXP",
icon_markup=icons.info,
action=lambda: None,
relevance=0.9,
plugin_name=self.display_name,
data={"type": "help", "keep_launcher_open": True}
),
Result(
title="Remove Account:",
subtitle="Example: remove gmail",
icon_markup=icons.trash,
action=lambda: None,
relevance=0.8,
plugin_name=self.display_name,
data={"type": "help", "keep_launcher_open": True}
)
]
def _handle_remove_command(self, account_name: str) -> List[Result]:
"""Handle removal of OTP account."""
if not account_name:
# Show all available accounts for removal
results = []
if not self.secrets:
results.append(Result(
title="No OTP accounts to remove",
subtitle="Use 'add <account> <secret>' to add accounts first",
icon_markup=icons.info,
action=lambda: None,
relevance=1.0,
plugin_name=self.display_name,
data={"type": "empty", "keep_launcher_open": True}
))
else:
results.append(Result(
title="Select account to remove:",
subtitle="Type: remove <account_name> to remove an account",
icon_markup=icons.trash,
action=lambda: None,
relevance=1.0,
plugin_name=self.display_name,
data={"type": "help", "keep_launcher_open": True}
))
# Get time display for consistency with main OTP view
time_display = self._get_time_remaining_with_blink()
# Show all accounts with their current OTP codes and remove actions
for acc_name, account_data in self.secrets.items():
secret = account_data.get("secret", "")
issuer = account_data.get("issuer", "")
display_name = f"{issuer} - {acc_name}" if issuer else acc_name
# Generate current TOTP code
totp_code = self._generate_totp(secret)
if totp_code:
results.append(Result(
title=f"{totp_code}",
subtitle_markup=f"Remove {display_name} • {time_display} remaining",
icon_markup=icons.trash,
action=lambda account=acc_name: self._remove_account_and_refresh(account),
relevance=0.9,
plugin_name=self.display_name,
data={"type": "remove_option", "account": acc_name, "code": totp_code, "keep_launcher_open": True}
))
else:
results.append(Result(
title=f"Error: {acc_name}",
subtitle=f"Remove {display_name} (Invalid secret)",
icon_markup=icons.trash,
action=lambda account=acc_name: self._remove_account_and_refresh(account),
relevance=0.8,
plugin_name=self.display_name,
data={"type": "remove_option", "account": acc_name, "keep_launcher_open": True}
))
return results
# Check if account exists
if account_name not in self.secrets:
return [Result(
title=f"Account '{account_name}' not found",
subtitle="Use 'remove' to see all available accounts",
icon_markup=icons.cancel,
action=lambda: None,
relevance=0.5,
plugin_name=self.display_name,
data={"type": "error", "keep_launcher_open": True}
)]
# Get account info for confirmation
account_data = self.secrets[account_name]
issuer = account_data.get("issuer", "")
display_name = f"{issuer} - {account_name}" if issuer else account_name
# Remove the account
try:
del self.secrets[account_name]
self._save_secrets()
return [Result(
title=f"✓ Removed '{display_name}'",
subtitle="OTP account removed successfully",
icon_markup=icons.check,
action=lambda: self._trigger_refresh(),
relevance=1.0,
plugin_name=self.display_name,
data={"type": "success", "keep_launcher_open": True}
)]
except Exception as e:
return [Result(
title="Error removing account",
subtitle=f"Failed to remove account: {str(e)}",
icon_markup=icons.cancel,
action=lambda: None,
relevance=0.5,
plugin_name=self.display_name,
data={"type": "error", "keep_launcher_open": True}
)]
def _handle_base32_secret(self, account_name: str, secret: str) -> List[Result]:
"""Handle raw Base32 secret."""
try:
# Clean up the secret - remove spaces, dashes, and convert to uppercase
clean_secret = secret.replace(" ", "").replace("-", "").replace("_", "").upper()
# Remove any non-base32 characters
import re
clean_secret = re.sub(r'[^A-Z2-7]', '', clean_secret)
# Add padding if needed (Base32 requires padding to multiple of 8)
while len(clean_secret) % 8 != 0:
clean_secret += '='
# Validate Base32 format
try:
base64.b32decode(clean_secret)
except Exception as e:
return [Result(
title="Invalid Base32 secret",
subtitle=f"Error: {str(e)}. Please check the secret format",
icon_markup=icons.cancel,
action=lambda: None,
relevance=0.5,
plugin_name=self.display_name,
data={"type": "error", "keep_launcher_open": True}
)]
# Test if the secret can generate a valid TOTP
try:
test_totp = pyotp.TOTP(clean_secret)
test_code = test_totp.now()
if not test_code or len(test_code) != 6:
raise ValueError("Generated invalid TOTP code")
except Exception as e:
return [Result(
title="Invalid secret for TOTP",
subtitle=f"Cannot generate TOTP: {str(e)}",
icon_markup=icons.cancel,
action=lambda: None,
relevance=0.5,
plugin_name=self.display_name,
data={"type": "error", "keep_launcher_open": True}
)]
self.secrets[account_name] = {
"secret": clean_secret,
"issuer": "",
"algorithm": "SHA1",
"digits": 6,
"period": 30
}
self._save_secrets()
return [Result(
title=f"✓ Added '{account_name}'",
subtitle=f"OTP account added successfully (secret: {clean_secret[:4]}...)",
icon_markup=icons.check,
action=lambda: self._trigger_refresh(),
relevance=1.0,
plugin_name=self.display_name,
data={"type": "success", "keep_launcher_open": True}
)]
except Exception as e:
return [Result(
title="Error adding account",
subtitle=f"Unexpected error: {str(e)}",
icon_markup=icons.cancel,
action=lambda: None,
relevance=0.5,
plugin_name=self.display_name,
data={"type": "error", "keep_launcher_open": True}
)]
def _handle_otpauth_uri(self, account_name: str, uri: str) -> List[Result]:
"""Handle otpauth:// URI."""
try:
from urllib.parse import urlparse, parse_qs
parsed = urlparse(uri)
if parsed.scheme != "otpauth" or parsed.netloc != "totp":
return [Result(
title="Invalid otpauth URI",
subtitle="Only otpauth://totp/ URIs are supported",
icon_markup=icons.cancel,
action=lambda: None,
relevance=0.5,
plugin_name=self.display_name,
data={"type": "error", "keep_launcher_open": True}
)]
if not account_name:
account_path = parsed.path.lstrip("/")
if ":" in account_path:
issuer, extracted_name = account_path.split(":", 1)
account_name = extracted_name
else:
account_name = account_path
params = parse_qs(parsed.query)
secret = params.get("secret", [""])[0]
issuer = params.get("issuer", [""])[0]
algorithm = params.get("algorithm", ["SHA1"])[0]
digits = int(params.get("digits", ["6"])[0])
period = int(params.get("period", ["30"])[0])
if not secret:
return [Result(
title="No secret in URI",
subtitle="otpauth URI must contain a secret parameter",
icon_markup=icons.cancel,
action=lambda: None,
relevance=0.5,
plugin_name=self.display_name,
data={"type": "error", "keep_launcher_open": True}
)]
self.secrets[account_name] = {
"secret": secret,
"issuer": issuer,
"algorithm": algorithm,
"digits": digits,
"period": period
}
self._save_secrets()
display_name = f"{issuer} - {account_name}" if issuer else account_name
return [Result(
title=f"✓ Added '{display_name}'",
subtitle="OTP account added from URI",
icon_markup=icons.check,
action=lambda: self._trigger_refresh(),
relevance=1.0,
plugin_name=self.display_name,
data={"type": "success", "keep_launcher_open": True}
)]
except Exception as e:
return [Result(
title="Error parsing otpauth URI",
subtitle=str(e),
icon_markup=icons.cancel,
action=lambda: None,
relevance=0.5,
plugin_name=self.display_name,
data={"type": "error", "keep_launcher_open": True}
)]
+18 -6
View File
@@ -58,24 +58,36 @@ class PowerPlugin(PluginBase):
def query(self, query_string: str) -> List[Result]:
"""Search power commands based on query."""
if not query_string.strip():
return []
query = query_string.lower().strip()
results = []
for cmd, info in self.commands.items():
if query in cmd.lower() or query in info["description"].lower():
# If no query, show all power commands
if not query:
for cmd, info in self.commands.items():
result = Result(
title=cmd.capitalize(),
subtitle=info["description"],
icon_markup=info["icon"],
action=info["action"],
relevance=1.0 if query == cmd else 0.7,
relevance=1.0,
plugin_name=self.display_name,
data={"command": cmd},
)
results.append(result)
else:
# Filter commands based on query
for cmd, info in self.commands.items():
if query in cmd.lower() or query in info["description"].lower():
result = Result(
title=cmd.capitalize(),
subtitle=info["description"],
icon_markup=info["icon"],
action=info["action"],
relevance=1.0 if query == cmd else 0.7,
plugin_name=self.display_name,
data={"command": cmd},
)
results.append(result)
return results
+187
View File
@@ -0,0 +1,187 @@
"""
Scripts plugin for the launcher.
Provides access to various system scripts and utilities.
"""
import os
import subprocess
from typing import List
from fabric.utils import exec_shell_command_async
import utils.icons as icons
from modules.launcher.plugin_base import PluginBase
from modules.launcher.result import Result
class ScriptsPlugin(PluginBase):
"""
Plugin for executing system scripts and utilities.
"""
def __init__(self):
super().__init__()
self.display_name = "Scripts"
self.description = "System scripts and utilities"
def initialize(self):
"""Initialize the scripts plugin."""
# Use individual trigger keywords for each specific action
self.set_triggers([
# Color picker variants
"color hex",
"color rgb",
"color hsv",
# Night light
"night"
])
def cleanup(self):
"""Cleanup the scripts plugin."""
pass
def _run_colorpicker(self, format_type: str):
"""Run color picker with specified format."""
script_path = self._get_script_path("hyprpicker.sh")
exec_shell_command_async(f"bash '{script_path}' -{format_type}")
def _get_script_path(self, script_name: str) -> str:
"""Get the full path to a script from the scripts directory."""
# Get the current working directory (should be Modus root)
current_dir = os.getcwd()
# Try scripts directory relative to current working directory
script_path = os.path.join(current_dir, "scripts", script_name)
if os.path.exists(script_path):
return script_path
# Try relative to this file's location
plugin_dir = os.path.dirname(os.path.abspath(__file__))
modus_root = os.path.dirname(os.path.dirname(os.path.dirname(plugin_dir)))
script_path = os.path.join(modus_root, "scripts", script_name)
if os.path.exists(script_path):
return script_path
# Fallback to relative path
return f"scripts/{script_name}"
def _get_trigger_actions(self) -> dict:
"""Get the map of trigger patterns to actions."""
return {
# Color picker triggers
"color hex": {
"title": "Color Picker (HEX)",
"subtitle": "Pick a color and copy HEX value to clipboard",
"icon": icons.colorpicker,
"action": lambda: self._run_colorpicker("hex"),
},
"color rgb": {
"title": "Color Picker (RGB)",
"subtitle": "Pick a color and copy RGB value to clipboard",
"icon": icons.colorpicker,
"action": lambda: self._run_colorpicker("rgb"),
},
"color hsv": {
"title": "Color Picker (HSV)",
"subtitle": "Pick a color and copy HSV value to clipboard",
"icon": icons.colorpicker,
"action": lambda: self._run_colorpicker("hsv"),
},
# Night light triggers
"night": {
"title": "Toggle Night Light",
"subtitle": "Toggle blue light filter for eye comfort",
"icon": icons.night,
"action": lambda: self._run_system_command("hyprctl keyword decoration:screen_shader ~/.config/hypr/shaders/blue_light_filter.glsl"),
}
}
def query(self, query_string: str) -> List[Result]:
"""Search for script actions based on query."""
query = query_string.strip().lower()
results = []
# Get trigger actions
trigger_actions = self._get_trigger_actions()
# If no query, return empty results (don't show all actions)
if not query:
return []
# Check if query exactly matches one of our triggers
# If so, show only that specific result
for trigger_key in trigger_actions:
if query == trigger_key.lower():
action_data = trigger_actions[trigger_key]
return [Result(
title=action_data["title"],
subtitle=action_data["subtitle"],
icon_markup=action_data["icon"],
action=action_data["action"],
relevance=1.0,
plugin_name=self.display_name,
data={"trigger": trigger_key}
)]
# Search through trigger actions for partial matches
for trigger, action_data in trigger_actions.items():
# Check if query matches trigger or is contained in title
if (query in trigger.lower() or
query in action_data["title"].lower() or
any(word in trigger.lower() for word in query.split())):
# Calculate relevance based on match quality
if query == trigger.lower():
relevance = 1.0
elif trigger.lower().startswith(query):
relevance = 0.9
elif query in trigger.lower():
relevance = 0.8
else:
relevance = 0.7
results.append(Result(
title=action_data["title"],
subtitle=action_data["subtitle"],
icon_markup=action_data["icon"],
action=action_data["action"],
relevance=relevance,
plugin_name=self.display_name,
data={"trigger": trigger}
))
return sorted(results, key=lambda x: x.relevance, reverse=True)
def query_triggered(self, _query_string: str, trigger: str) -> List[Result]:
"""
Process a triggered query (when plugin is activated by a specific trigger).
Show only the specific result for the triggered keyword.
"""
# Get trigger actions
trigger_actions = self._get_trigger_actions()
# Find the exact trigger match and return only that result
trigger_lower = trigger.lower().strip()
if trigger_lower in trigger_actions:
action_data = trigger_actions[trigger_lower]
return [Result(
title=action_data["title"],
subtitle=action_data["subtitle"],
icon_markup=action_data["icon"],
action=action_data["action"],
relevance=1.0,
plugin_name=self.display_name,
data={"trigger": trigger_lower}
)]
# If no exact match found, return empty list
return []
+99 -18
View File
@@ -9,14 +9,16 @@ import hashlib
import colorsys
import re
import json
from typing import List
from typing import List, Dict, Optional
from PIL import Image
from gi.repository import GdkPixbuf
from gi.repository import GdkPixbuf, GLib
from modules.launcher.plugin_base import PluginBase
from modules.launcher.result import Result
from fabric.utils.helpers import exec_shell_command_async
import config.data as data
import utils.icons as icons
import threading
import time
class WallpaperPlugin(PluginBase):
@@ -29,6 +31,8 @@ class WallpaperPlugin(PluginBase):
self.display_name = "Wallpaper"
self.wallpapers = []
self.cache_dir = f"{data.CACHE_DIR}/thumbs"
self.thumbnail_cache: Dict[str, Optional[GdkPixbuf.Pixbuf]] = {}
self.thumbnail_loading = set() # Track which thumbnails are being loaded
self.schemes = {
"scheme-tonal-spot": "Tonal Spot",
"scheme-content": "Content",
@@ -45,6 +49,8 @@ class WallpaperPlugin(PluginBase):
self.set_triggers(["wall", "wall "])
self._load_wallpapers()
os.makedirs(self.cache_dir, exist_ok=True)
# Start background thumbnail creation
self._start_background_thumbnail_creation()
def cleanup(self):
"""Cleanup the wallpaper plugin."""
@@ -127,15 +133,96 @@ class WallpaperPlugin(PluginBase):
if not os.path.exists(cache_path):
try:
with Image.open(full_path) as img:
# Use faster thumbnail creation
img.thumbnail((48, 48), Image.Resampling.LANCZOS)
img.save(cache_path, "PNG")
# Use faster thumbnail creation with smaller size for better performance
img.thumbnail((32, 32), Image.Resampling.LANCZOS)
img.save(cache_path, "PNG", optimize=True)
except Exception as e:
print(f"Error creating thumbnail for {filename}: {e}")
return None
return cache_path
def _start_background_thumbnail_creation(self):
"""Start background thread to create thumbnails for all wallpapers."""
def create_thumbnails():
for wallpaper in self.wallpapers:
if wallpaper not in self.thumbnail_loading:
self.thumbnail_loading.add(wallpaper)
try:
cache_path = self._create_thumbnail(wallpaper)
if cache_path and os.path.exists(cache_path):
# Load thumbnail into memory cache
try:
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(
cache_path, 32, 32, True
)
self.thumbnail_cache[wallpaper] = pixbuf
except Exception as e:
print(f"Error loading thumbnail for {wallpaper}: {e}")
self.thumbnail_cache[wallpaper] = None
else:
self.thumbnail_cache[wallpaper] = None
except Exception as e:
print(f"Error processing thumbnail for {wallpaper}: {e}")
self.thumbnail_cache[wallpaper] = None
finally:
self.thumbnail_loading.discard(wallpaper)
# Small delay to prevent overwhelming the system
time.sleep(0.01)
# Start background thread
thread = threading.Thread(target=create_thumbnails, daemon=True)
thread.start()
def _get_thumbnail_fast(self, filename: str) -> Optional[GdkPixbuf.Pixbuf]:
"""Get thumbnail quickly from cache or return None if not ready."""
# Return cached thumbnail if available
if filename in self.thumbnail_cache:
return self.thumbnail_cache[filename]
# Check if thumbnail file exists and load it immediately
cache_path = self._get_cache_path(filename)
if os.path.exists(cache_path):
try:
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(
cache_path, 32, 32, True
)
self.thumbnail_cache[filename] = pixbuf
return pixbuf
except Exception as e:
print(f"Error loading thumbnail for {filename}: {e}")
self.thumbnail_cache[filename] = None
return None
# If not in cache and file doesn't exist, trigger background creation
if filename not in self.thumbnail_loading:
self.thumbnail_loading.add(filename)
def create_async():
try:
cache_path = self._create_thumbnail(filename)
if cache_path and os.path.exists(cache_path):
try:
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_scale(
cache_path, 32, 32, True
)
self.thumbnail_cache[filename] = pixbuf
except Exception as e:
print(f"Error loading thumbnail for {filename}: {e}")
self.thumbnail_cache[filename] = None
else:
self.thumbnail_cache[filename] = None
except Exception as e:
print(f"Error creating thumbnail for {filename}: {e}")
self.thumbnail_cache[filename] = None
finally:
self.thumbnail_loading.discard(filename)
thread = threading.Thread(target=create_async, daemon=True)
thread.start()
return None
def _set_wallpaper(self, filename: str, scheme: str = None):
"""Set wallpaper with optional matugen integration."""
full_path = os.path.join(data.WALLPAPERS_DIR, filename)
@@ -749,22 +836,16 @@ class WallpaperPlugin(PluginBase):
relevance = 0.8
matching_wallpapers.append((wallpaper, relevance))
# Sort by relevance - no limit since we use bypass_max_results
# Sort by relevance and limit results for better performance
matching_wallpapers.sort(key=lambda x: x[1], reverse=True)
for wallpaper, relevance in matching_wallpapers:
# Only create thumbnails for displayed results
cache_path = self._get_cache_path(wallpaper)
icon = None
# Limit to first 50 results for performance (can be increased if needed)
max_results = 50 if query else 20 # Show fewer when no query to load faster
matching_wallpapers = matching_wallpapers[:max_results]
# Try to load existing thumbnail first
if os.path.exists(cache_path):
try:
icon = GdkPixbuf.Pixbuf.new_from_file_at_scale(
cache_path, 32, 32, True
)
except Exception as e:
print(f"Error loading existing thumbnail: {e}")
for wallpaper, relevance in matching_wallpapers:
# Use fast thumbnail loading
icon = self._get_thumbnail_fast(wallpaper)
results.append(
Result(