activity-driver 1.0.0__py3-none-any.whl

activity_driver/__init__.py

@@ -0,0 +1,26 @@
+"""
+Activity Driver — Coty Engineering
+===================================
+Simulates realistic user activity for Prohance tracking.
+Prevents macOS idle sleep and auto-logout.
+
+Components:
+  - activity_driver    : Main event simulation engine
+  - hid_events        : Real OS-level HID event generation
+  - daily_report      : Live dashboard at http://localhost:3006
+  - launcher          : Orchestrates activity_driver + daily_report
+  - config            : User configuration management
+
+Version: 1.0.0
+License: Proprietary (Coty Engineering)
+"""
+
+__version__ = "1.0.0"
+__author__ = "Coty Engineering"
+__all__ = [
+    "activity_driver",
+    "hid_events",
+    "daily_report",
+    "launcher",
+    "config",
+]

activity_driver/activity_driver.py

@@ -0,0 +1,350 @@
+#!/usr/bin/env python3
+"""
+Activity Driver — Coty Engineering
+====================================
+Fires browser + file events mapped ONLY to Prohance +2 productive categories.
+
+Productive categories targeted (all rated +2 in your account):
+  • SharePoint           → coty-my.sharepoint.com
+  • IT Support/Sites     → coty.service-now.com
+  • Internal apps        → app.contentstack.com, dam.coty.com, supplier.coty.com
+  • Documentation Tool   → app.contentstack.com, app.gitbook.com
+  • Cotypbb2b            → pim.coty.com
+  • ProHance             → ind1.prohance.io
+  • File system (+2)     → Python file writes to _notes/
+
+Eliminates:
+  x UNKNOWN  — all brand/retail/unrated URLs removed
+  x TAFS     — foreground browser open keeps active window alive
+  x Not Rated — Google searches removed entirely
+
+No admin rights needed. Stop with Ctrl-C.
+"""
+
+import json
+import os
+import random
+import string
+import subprocess
+import threading
+import time
+from datetime import datetime, date, timedelta
+from pathlib import Path
+
+# Real HID event generation (recognized by Prohance as actual user input)
+try:
+    from . import hid_events
+    from .hid_events import inject_mouse_move, click_mouse, scroll_mouse, press_key, random_mouse_activity, random_keyboard_activity
+    HAS_HID_EVENTS = True
+except ImportError:
+    HAS_HID_EVENTS = False
+    print("⚠️  hid_events module not found. Falling back to synthetic events only.")
+
+# Configuration management
+from . import config
+
+BASE_DIR  = Path(__file__).parent
+NOTES_DIR = BASE_DIR / ".cache"          # less obvious than _notes
+LOG_FILE  = BASE_DIR / ".session_data"   # hidden dot-file, not obvious
+
+# ChromAPP         = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+
+# Load configuration from user settings
+_cfg = config.load_config()
+CHROME_PROFILE     = _cfg.get("chrome_profile", "Profile 1")
+INTERVAL_MIN       = _cfg.get("interval_min", 30)
+INTERVAL_MAX       = _cfg.get("interval_max", 55)
+UNIQUE_RATIO       = _cfg.get("unique_ratio", 0.50)
+
+INTERVAL_MIN       = 30      # normal lower bound (must be < TAB_OPEN_MIN)
+INTERVAL_MAX       = 55      # normal upper bound
+UNIQUE_RATIO       = 0.50
+TOTAL_EVENTS       = 0
+LOG_EVENTS         = True
+SWITCH_APPS        = False
+LOG_RETENTION_DAYS = 2
+
+# Heartbeat — single long-lived caffeinate process, no per-event spawning
+# -u asserts kIOPMAssertionUserIsActive every HEARTBEAT_INTERVAL seconds
+HEARTBEAT_INT_cfg.get("burst_prob", 0.20)
+BURST_MIN  = 5
+BURST_MAX  = 12
+
+# Deep-read pause: ~12% chance of a 2-4 min pause (reading a long doc)
+DEEP_READ_PROB = _cfg.get("deep_read_prob", 0.12)
+
+# Deep-read pause: ~12% chance of a 2-4 min pause (reading a long doc)
+DEEP_READ_PROB = 0.12
+DEEP_READ_MIN  = 120
+DEEP_READ_MAX  = 150   # capped at 2.5 min — below Prohance 3-min idle threshold
+
+# Anti-idle: guaranteed lightweight event fired every N seconds regardless of
+# what the main loop is doing (deep-read, burst, or normal wait).
+# Keeps Prohance idle gap = 0 by ensuring no silence > threshold.
+ANTI_IDLE_INTERVAL = 90   # seconds — safely under any Prohance idle threshold
+
+# Load productive URLs from configuration
+_productive_urls = config.get_productive_urls()
+
+# Weighted repeated — core daily tools (hit more often = natural)
+REPEATED_URLS = _productive_urls + _productive_urls[:len(_productive_urls)//2]  # Weight by repeating
+
+# Unique — visited once in a while for variety (variants of base URLs)
+UNIQUE_URLS = _productive_urls.copy()
+
+REPEATED_PHRASES = [
+    "Reviewing project documentation",
+    "Checking task list for today",
+    "Updating sprint board",
+    "Running QA checks",
+    "Reading pull request comments",
+]
+
+# Clipboard snippets — realistic work content copied during a session
+CLIPBOARD_SNIPPETS = [
+    "TSID=Media-Management&view=grid",
+    "sprint-review-notes-2026",
+    "contentstack-environment-production",
+    "dam-asset-id-cx90021",
+    "PIM-SKU-7743829",
+    "serviceNow-INC0049321",
+    "sharepoint-site-coty-emea",
+    "gitbook-space-engineering-wiki",
+    "supplier-portal-onboarding-checklist",
+    "staging.pim.coty.com/products/list",
+]
+
+# How long to keep a browser tab open before auto-closing (seconds)
+# Must be > INTERVAL_MAX to avoid tab pile-up from overlapping opens
+TAB_OPEN_MIN = 50
+TAB_OPEN_MAX = 75
+
+TOPICS = [
+    "CoverGirl US", "Sally Hansen", "Rimmel London", "Max Factor",
+    "ContentStack CMS", "DAM media library", "PIM product data",
+    "ServiceNow ticket", "SharePoint docs", "Coty Institute",
+    "Beckham Fragrances", "Jil Sander", "Manhattan DE",
+]
+
+
+# ── JSON log with 2-day retention ─────────────────────────────────────────────
+
+def load_log():
+    if LOG_FILE.exists():
+        try:
+            return json.loads(LOG_FILE.read_text())
+        except Exception:
+            return []
+    return []
+
+def save_log(entries):
+    LOG_FILE.write_text(json.dumps(entries, indent=2))
+
+def purge_old_entries(entries):
+    cutoff = (date.today() - timedelta(days=LOG_RETENTION_DAYS - 1)).isoformat()
+    kept   = [e for e in entries if e.get("date", "") >= cutoff]
+    purged = len(entries) - len(kept)
+    if purged:
+        print(f"  [log] Purged {purged} entries older than {LOG_RETENTION_DAYS} days.")
+    return kept
+
+def log_event(entries, event_type, label, detail):
+    now = datetime.now()
+    entries.append({
+        "ts":    now.isoformat(timespec="seconds"),
+        "date":  now.date().isoformat(),
+        "hour":  now.hour,
+        "type":  event_type,
+        "label": label,
+        "detail": detail,
+    })
+
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+def log_console(label, detail):
+    if LOG_EVENTS:
+        print(f"[{datetime.now().strftime('%H:%M:%S')}]  {label:<24} {detail}")
+
+def run_applescript(script):
+    try:
+        subprocess.run(["osascript"], input=script.encode(),
+                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=8)
+        return True
+    except Exception:
+        return False
+
+def close_tab_by_domain(domain):
+    """Close ALL browser tabs matching a domain (not just the first)."""
+    safe = domain.replace('"', '')
+    chrome_script = f'''
+tell application "Google Chrome"
+    repeat with w in windows
+        set tabsToClose to {{}}
+        repeat with t in (every tab of w)
+            if URL of t contains "{safe}" then
+                set end of tabsToClose to t
+            end if
+        end repeat
+        repeat with t in tabsToClose
+            close t
+        end repeat
+    end repeat
+end tell
+'''
+    safari_script = f'''
+tell application "Safari"
+    repeat with w in windows
+        set tabsToClose to {{}}
+        repeat with t in (every tab of w)
+            if URL of t contains "{safe}" then
+                set end of tabsToClose to t
+            end if
+        end repeat
+        repeat with t in tabsToClose
+            close t
+        end repeat
+    end repeat
+end tell
+'''
+    run_applescript(chrome_script)
+    run_applescript(safari_script)
+
+
+def inject_js(js):
+    """Run JavaScript in the active Chrome tab — no Accessibility permission needed.
+    Uses Chrome's own AppleScript dictionary (not System Events)."""
+    script = f'''
+tell application "Google Chrome"
+    if (count of windows) > 0 then
+        execute front window's active tab javascript "{js}"
+    end if
+end tell
+'''
+    run_applescript(script)
+
+
+def simulate_reading(url):
+    """After page load: scroll down gradually (like a human reading), then maybe back up.
+    All via JS injection — zero HID/Accessibility permission required."""
+    time.sleep(random.uniform(1.5, 3.0))   # wait for page to render
+    # scroll down in 2-4 steps
+    steps = random.randint(2, 4)
+    for _ in range(steps):
+        px = random.randint(120, 400)
+        inject_js(f"window.scrollBy({{top:{px},behavior:'smooth'}});")
+        time.sleep(random.uniform(1.8, 4.5))
+    # 40% chance: scroll back up (simulates re-reading)
+    if random.random() < 0.40:
+        time.sleep(random.uniform(1.0, 2.5))
+        inject_js("window.scrollTo({top:0,behavior:'smooth'});")
+        time.sleep(random.uniform(0.8, 2.0))
+
+
+def open_url(url):
+    subprocess.Popen(
+        [CHROME_APP, f"--profile-directory={CHROME_PROFILE}", url],
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+    )
+    # Simulate reading the page in a background thread (scroll events, no Accessibility)
+    threading.Thread(target=simulate_reading, args=[url], daemon=True).start()
+    # Schedule tab close after a realistic reading time
+    domain = url.replace("https://", "").split("/")[0]
+    delay  = random.uniform(TAB_OPEN_MIN, TAB_OPEN_MAX)
+    threading.Timer(delay, close_tab_by_domain, args=[domain]).start()
+
+def write_note(content):
+    NOTES_DIR.mkdir(exist_ok=True)
+    suffix = "".join(random.choices(string.ascii_letters, k=6))
+    path   = NOTES_DIR / f"note_{suffix}.txt"
+    path.write_text(content)
+    return path
+
+def delete_note(path):
+    try:
+        path.unlink()
+    except OSError:
+        pass
+
+
+# ── events ────────────────────────────────────────────────────────────────────
+
+def event_url_repeated(entries):
+    url = random.choice(REPEATED_URLS)
+    open_url(url)
+    log_event(entries, "BROWSER", "repeated", url)
+    return ("BROWSER [repeated]", url)
+
+def event_url_unique(entries):
+    url = random.choice(UNIQUE_URLS)
+    open_url(url)
+    log_event(entries, "BROWSER", "unique", url[:80])
+    return ("BROWSER [unique]", url[:80])
+
+def event_clipboard(entries):
+    """Write a realistic work snippet to the system clipboard — no admin needed."""
+    snippet = random.choice(CLIPBOARD_SNIPPETS)
+    try:
+        subprocess.run(["pbcopy"], input=snippet.encode(), timeout=3, capture_output=True)
+    except Exception:
+        pass
+
+def main():
+    """Main activity driver loop."""
+    print("=" * 60)
+    print("  Activity Driver — Coty Engineering")
+    print("  Simulating realistic work activity...")
+    print(f"  HID events enabled: {HAS_HID_EVENTS}")
+    print(f"  Log file: {LOG_FILE}")
+    print(f"  Config file: {config.CONFIG_FILE}")
+    print(f"  Productive URLs: {len(REPEATED_URLS)}")
+    print("  Stop with Ctrl-C")
+    print("=" * 60 + "\n")
+
+    entries = load_log()
+    entries = purge_old_entries(entries)
+
+    # Start caffeinate heartbeat in background
+    caffeinate_proc = subprocess.Popen(
+        ["caffeinate", "-u", "-t", str(int(HEARTBEAT_INTERVAL * 10))],
+        stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+    )
+
+    try:
+        while True:
+            # Decide next event type
+            if random.random() < BURST_PROB:
+                wait = random.uniform(BURST_MIN, BURST_MAX)
+            elif random.random() < DEEP_READ_PROB:
+                wait = random.uniform(DEEP_READ_MIN, DEEP_READ_MAX)
+            else:
+                wait = random.uniform(INTERVAL_MIN, INTERVAL_MAX)
+
+            # Schedule anti-idle event in parallel
+            def anti_idle():
+                time.sleep(ANTI_IDLE_INTERVAL)
+                if HAS_HID_EVENTS:
+                    random_mouse_activity()
+
+            threading.Thread(target=anti_idle, daemon=True).start()
+
+            # Fire event
+            if random.random() < UNIQUE_RATIO:
+                label, detail = event_url_unique(entries)
+            else:
+                label, detail = event_url_repeated(entries)
+
+            log_console(label, detail)
+            save_log(entries)
+
+            time.sleep(wait)
+    except KeyboardInterrupt:
+        print("\n[driver] Stopping...")
+    finally:
+        caffeinate_proc.terminate()
+        save_log(entries)
+        print("[driver] Done.")
+
+
+if __name__ == "__main__":
+    main()

activity_driver/config.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""
+Configuration manager for Activity Driver
+Handles loading, saving, and managing user preferences
+"""
+
+import json
+from pathlib import Path
+from typing import Dict, List, Any
+
+# Config location: ~/.config/activity-driver/config.json
+CONFIG_DIR = Path.home() / ".config" / "activity-driver"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+# Default configuration
+DEFAULT_CONFIG = {
+    "version": "1.0.0",
+    "productive_urls": [
+        "https://coty-my.sharepoint.com/shared",
+        "https://app.contentstack.com/",
+        "https://dam.coty.com",
+        "https://coty.service-now.com/",
+        "https://pim.coty.com",
+        "https://app.gitbook.com",
+        "https://supplier.coty.com",
+    ],
+    "chrome_profile": "Profile 1",
+    "interval_min": 30,
+    "interval_max": 55,
+    "unique_ratio": 0.50,
+    "burst_prob": 0.20,
+    "deep_read_prob": 0.12,
+    "dashboard_enabled": False,
+    "dashboard_port": 3006,
+}
+
+
+def ensure_config_dir():
+    """Create config directory if it doesn't exist."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> Dict[str, Any]:
+    """Load configuration from file, or return defaults if not found."""
+    ensure_config_dir()
+    
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text())
+        except Exception as e:
+            print(f"Warning: Could not load config ({e}), using defaults")
+            return DEFAULT_CONFIG.copy()
+    
+    return DEFAULT_CONFIG.copy()
+
+
+def save_config(config: Dict[str, Any]):
+    """Save configuration to file."""
+    ensure_config_dir()
+    CONFIG_FILE.write_text(json.dumps(config, indent=2))
+
+
+def get_productive_urls() -> List[str]:
+    """Get the list of productive URLs."""
+    config = load_config()
+    return config.get("productive_urls", DEFAULT_CONFIG["productive_urls"])
+
+
+def set_productive_urls(urls: List[str]):
+    """Update the list of productive URLs."""
+    config = load_config()
+    config["productive_urls"] = urls
+    save_config(config)
+
+
+def get_setting(key: str, default=None):
+    """Get a specific configuration setting."""
+    config = load_config()
+    if default is None:
+        default = DEFAULT_CONFIG.get(key)
+    return config.get(key, default)
+
+
+def set_setting(key: str, value: Any):
+    """Set a specific configuration setting."""
+    config = load_config()
+    config[key] = value
+    save_config(config)
+
+
+def get_all_config() -> Dict[str, Any]:
+    """Get entire configuration."""
+    return load_config()
+
+
+def set_all_config(config: Dict[str, Any]):
+    """Replace entire configuration."""
+    save_config(config)
+
+
+def reset_to_defaults():
+    """Reset configuration to defaults."""
+    ensure_config_dir()
+    CONFIG_FILE.write_text(json.dumps(DEFAULT_CONFIG, indent=2))
+    return DEFAULT_CONFIG.copy()
+
+
+def config_exists() -> bool:
+    """Check if configuration file exists."""
+    return CONFIG_FILE.exists()
+
+
+def print_config():
+    """Pretty print the current configuration."""
+    config = load_config()
+    print("\n" + "=" * 60)
+    print("  Activity Driver Configuration")
+    print("=" * 60)
+    print(f"\n  Config file: {CONFIG_FILE}\n")
+    
+    print("  Productive URLs:")
+    for i, url in enumerate(config.get("productive_urls", []), 1):
+        print(f"    {i}. {url}")
+    
+    print(f"\n  Chrome Profile: {config.get('chrome_profile', 'Profile 1')}")
+    print(f"  Event Interval: {config.get('interval_min', 30)}-{config.get('interval_max', 55)}s")
+    print(f"  Unique URL Ratio: {config.get('unique_ratio', 0.50) * 100:.0f}%")
+    
+    dashboard = config.get('dashboard_enabled', False)
+    port = config.get('dashboard_port', 3006)
+    if dashboard:
+        print(f"\n  Dashboard: ENABLED (http://localhost:{port})")
+    else:
+        print(f"\n  Dashboard: DISABLED")
+    
+    print(f"  Burst Probability: {config.get('burst_prob', 0.20) * 100:.0f}%")
+    print(f"  Deep Read Probability: {config.get('deep_read_prob', 0.12) * 100:.0f}%")
+    print("\n" + "=" * 60 + "\n")
+
+
+if __name__ == "__main__":
+    # Simple CLI for testing
+    import sys
+    
+    if len(sys.argv) > 1:
+        cmd = sys.argv[1]
+        
+        if cmd == "show":
+            print_config()
+        elif cmd == "reset":
+            reset_to_defaults()
+            print("✓ Configuration reset to defaults")
+        elif cmd == "path":
+            print(CONFIG_FILE)
+        else:
+            print(f"Unknown command: {cmd}")
+            print("Available: show, reset, path")
+    else:
+        print_config()
+
+
+def cli_main():
+    """CLI entry point for activity-config command."""
+    import sys
+    
+    if len(sys.argv) < 2:
+        # Show interactive menu
+        print("\n" + "=" * 60)
+        print("  Activity Driver — Configuration Manager")
+        print("=" * 60)
+        print("\nCommands:")
+        print("  activity-config show         Display current configuration")
+        print("  activity-config domains      Edit productive domains")
+        print("  activity-config profile      Change Chrome profile")
+        print("  activity-config reset        Reset to defaults")
+        print("  activity-config path         Show config file path")
+        print("=" * 60 + "\n")
+        return
+    
+    cmd = sys.argv[1]
+    
+    if cmd == "show":
+        print_config()
+    
+    elif cmd == "path":
+        ensure_config_dir()
+        print(CONFIG_FILE)
+    
+    elif cmd == "reset":
+        response = input("⚠️  Reset configuration to defaults? (y/N): ")
+        if response.lower() in ['y', 'yes']:
+            reset_to_defaults()
+            print("✓ Configuration reset to defaults\n")
+        else:
+            print("Cancelled\n")
+    
+    elif cmd == "domains":
+        print("\n" + "=" * 60)
+        print("  Edit Productive Domains")
+        print("=" * 60 + "\n")
+        
+        # Show current
+        print("Current productive domains:")
+        urls = get_productive_urls()
+        for i, url in enumerate(urls, 1):
+            print(f"  {i}. {url}")
+        
+        print("\nEnter new domains (press Enter twice to finish):")
+        new_domains = []
+        counter = 1
+        while True:
+            domain = input(f"  Domain {counter}: ").strip()
+            if not domain:
+                if new_domains:
+                    break
+                else:
+                    print("  Please enter at least one domain.")
+                    continue
+            new_domains.append(domain)
+            counter += 1
+        
+        set_productive_urls(new_domains)
+        print(f"\n✓ Saved {len(new_domains)} productive domain(s)\n")
+        print_config()
+    
+    elif cmd == "profile":
+        print("\n" + "=" * 60)
+        print("  Configure Chrome Profile")
+        print("=" * 60 + "\n")
+        
+        current_profile = get_setting('chrome_profile')
+        print(f"Current Chrome profile: {current_profile}")
+        print(f"Find yours at: chrome://version → Profile Path (last segment)")
+        
+        new_profile = input("\nEnter new Chrome profile name: ").strip()
+        if not new_profile:
+            print("✗ Profile name cannot be empty\n")
+            return
+        
+        set_setting('chrome_profile', new_profile)
+        print(f"✓ Chrome profile set to: {new_profile}\n")
+    
+    elif cmd == "dashboard":
+        print("\n" + "=" * 60)
+        print("  Configure Dashboard")
+        print("=" * 60 + "\n")
+        
+        current_enabled = get_setting('dashboard_enabled', False)
+        current_port = get_setting('dashboard_port', 3006)
+        
+        status = "ENABLED" if current_enabled else "DISABLED"
+        print(f"Dashboard Status: {status}")
+        if current_enabled:
+            print(f"Port: {current_port}")
+        
+        response = input("\nEnable dashboard? (y/n): ").strip().lower()
+        
+        if response in ['y', 'yes']:
+            port_input = input("Enter dashboard port [3006]: ").strip()
+            port = int(port_input) if port_input else 3006
+            set_setting('dashboard_enabled', True)
+            set_setting('dashboard_port', port)
+            print(f"✓ Dashboard enabled on port {port}\n")
+        elif response in ['n', 'no']:
+            set_setting('dashboard_enabled', False)
+            print(f"✓ Dashboard disabled\n")
+        else:
+            print("✗ Invalid response\n")
+            return
+    
+    else:
+        print(f"Unknown command: {cmd}\n")
+        print("Valid commands: show, domains, profile, dashboard, reset, path\n")