feat: cross-device support — all Apple devices, cloud tool delegation, PWA

- Fix uninstall permission errors (sudo for /Applications)
- Fix mac app not opening (hardcode JARVIS_DIR in C launcher)
- Fix mic staying on after 'bye' (standby mode, menu bar indicator)
- Fix calendar permission spam (cached permission checks)
- Fix app opening (alias mapping: camera→FaceTime, vscode→VS Code, etc.)
- Add startup automation permission requests from JARVIS process
- Server error retry prompt in conversation loop

Cloud tool delegation:
- Tag 78 macOS-only tools (osascript/subprocess)
- Auto-delegate to connected Mac via WebSocket when server runs on Linux
- Listener connects to server WebSocket, executes tools locally, returns results
- 26 tools run directly in cloud (web search, weather, tasks, memory, etc.)

iPhone/iPad/Apple Watch:
- Siri Shortcut now hits HF Space (not localhost) — works on all Apple devices
- Shortcut: dictate → POST /api/ask → speak response → notification
- PWA: apple-touch-icons (152/167/180px), safe area insets, iPad layout
- iOS install prompt with device detection, don't-show-again option
- manifest.json with full icon set, service worker v2

WebView app:
- Try local server → HF Space → Render → error page
- No local HTML dependency, loads server UI directly

.gitignore

@@ -13,3 +13,4 @@ JARVIS-Listener.app/
 JARVIS.app/
 *.icns
 *.shortcut
+.device_id

install.sh

@@ -90,28 +90,26 @@ fi
 
 # Create the native launcher binary
 # A compiled binary means macOS TCC properly identifies this app for mic permission
-cat > /tmp/jarvis_launcher.c << 'CSOURCE'
+# Uses JARVIS_DIR hardcoded at build time so it works even if .app is moved
+cat > /tmp/jarvis_launcher.c << CSOURCE
 #include <unistd.h>
-#include <libgen.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <mach-o/dyld.h>
+
+#define JARVIS_DIR "$JARVIS_DIR"
 
 int main(int argc, char *argv[]) {
-    char exe_path[4096];
-    uint32_t size = sizeof(exe_path);
-    _NSGetExecutablePath(exe_path, &size);
-    char *dir = dirname(exe_path);
-    dir = dirname(dir);
-    dir = dirname(dir);
-    dir = dirname(dir);
     char python_path[4096];
     char script_path[4096];
-    snprintf(python_path, sizeof(python_path), "%s/venv/bin/python", dir);
-    snprintf(script_path, sizeof(script_path), "%s/jarvis_listener.py", dir);
-    chdir(dir);
-    execl(python_path, python_path, script_path, NULL);
+    snprintf(python_path, sizeof(python_path), "%s/venv/bin/python", JARVIS_DIR);
+    snprintf(script_path, sizeof(script_path), "%s/jarvis_listener.py", JARVIS_DIR);
+    chdir(JARVIS_DIR);
+    /* Forward any extra args (e.g. --no-greet) */
+    if (argc > 1) {
+        execl(python_path, python_path, script_path, argv[1], NULL);
+    } else {
+        execl(python_path, python_path, script_path, NULL);
+    }
     perror("Failed to launch JARVIS listener");
     return 1;
 }
@@ -196,26 +194,20 @@ if [ -f "$JARVIS_DIR/static/JARVIS.icns" ]; then
 fi
 
 # Create launcher that runs jarvis_app.py (the WebView)
-cat > /tmp/jarvis_app_launcher.c << 'CSOURCE'
+# Uses JARVIS_DIR hardcoded at build time so it works from /Applications too
+cat > /tmp/jarvis_app_launcher.c << CSOURCE
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <mach-o/dyld.h>
-#include <libgen.h>
+
+#define JARVIS_DIR "$JARVIS_DIR"
 
 int main(int argc, char *argv[]) {
-    char exe_path[4096];
-    uint32_t size = sizeof(exe_path);
-    _NSGetExecutablePath(exe_path, &size);
-    char *dir = dirname(exe_path);
-    dir = dirname(dir);
-    dir = dirname(dir);
-    dir = dirname(dir);
     char python_path[4096];
     char script_path[4096];
-    snprintf(python_path, sizeof(python_path), "%s/venv/bin/python", dir);
-    snprintf(script_path, sizeof(script_path), "%s/jarvis_app.py", dir);
-    chdir(dir);
+    snprintf(python_path, sizeof(python_path), "%s/venv/bin/python", JARVIS_DIR);
+    snprintf(script_path, sizeof(script_path), "%s/jarvis_app.py", JARVIS_DIR);
+    chdir(JARVIS_DIR);
     execl(python_path, python_path, script_path, NULL);
     perror("Failed to launch JARVIS app");
     return 1;
@@ -341,10 +333,18 @@ except Exception as e:
 
 # 6e. AppleScript / Automation (Notes, Calendar, Mail, Finder, etc.)
 echo "  Requesting automation access (Notes, Calendar, Mail, Finder)..."
-for APP_NAME in "Notes" "Calendar" "Reminders" "Mail" "Finder" "System Events"; do
+echo "  NOTE: Automation permissions are requested when JARVIS first starts."
+echo "  When JARVIS launches, macOS will prompt you to allow it to control"
+echo "  each app. Click 'OK' or 'Allow' for each prompt."
+echo ""
+echo "  If you don't see prompts, go to:"
+echo "  System Settings → Privacy & Security → Automation → enable JARVIS"
+echo ""
+# Still trigger from Terminal for any that might work
+for APP_NAME in "System Events" "Finder"; do
     osascript -e "tell application \"$APP_NAME\" to name" 2>/dev/null && \
-        echo "  ✓ Automation: $APP_NAME" || \
-        echo "  [!] Automation: $APP_NAME — grant when prompted"
+        echo "  ✓ Automation: $APP_NAME (Terminal)" || \
+        echo "  [i] Automation: $APP_NAME — will prompt when JARVIS starts"
 done
 
 # 6f. Contacts
@@ -520,28 +520,28 @@ echo "  ✓ All services launched (listener includes menu bar)"
 
 echo ""
 echo "  ╔═══════════════════════════════════════╗"
-echo "  ║   J.A.R.V.I.S. INSTALLED             ║"
+echo "  ║   J.A.R.V.I.S. INSTALLED              ║"
 echo "  ║                                       ║"
-echo "  ║   ✓ Server: auto-starts on boot      ║"
-echo "  ║   ✓ Listener: wake+clap+hotkey+menu  ║"
-echo "  ║   ✓ JARVIS.app: in /Applications     ║"
-echo "  ║   ✓ Menu bar: J icon (unified)       ║"
-echo "  ║   ✓ Siri Shortcut: Hey Siri, JARVIS  ║"
-echo "  ║   ✓ Clap/Snap: double-clap to wake   ║"
-echo "  ║   ✓ All permissions: requested       ║"
+echo "  ║   ✓ Server: auto-starts on boot       ║"
+echo "  ║   ✓ Listener: wake+clap+hotkey+menu   ║"
+echo "  ║   ✓ JARVIS.app: in /Applications      ║"
+echo "  ║   ✓ Menu bar: J icon (unified)        ║"
+echo "  ║   ✓ Siri Shortcut: Hey Siri, JARVIS   ║"
+echo "  ║   ✓ Clap/Snap: double-clap to wake    ║"
+echo "  ║   ✓ All permissions: requested        ║"
 echo "  ║                                       ║"
 echo "  ║   Activation:                         ║"
-echo "  ║   • Open JARVIS.app (WebView UI)     ║"
-echo "  ║   • Say 'Hey Siri, JARVIS'           ║"
-echo "  ║   • Say 'Jarvis' (local wake word)   ║"
-echo "  ║   • Ctrl+Shift+J (global hotkey)     ║"
-echo "  ║   • Double clap or snap              ║"
-echo "  ║   • Click J in menu bar              ║"
+echo "  ║   • Open JARVIS.app (WebView UI)      ║"
+echo "  ║   • Say 'Hey Siri, JARVIS'            ║"
+echo "  ║   • Say 'Jarvis' (local wake word)    ║"
+echo "  ║   • Ctrl+Shift+J (global hotkey)      ║"
+echo "  ║   • Double clap or snap               ║"
+echo "  ║   • Click J in menu bar               ║"
 echo "  ║                                       ║"
 echo "  ║   Conversation mode:                  ║"
 echo "  ║   • After wake, mic stays on          ║"
 echo "  ║   • Ask follow-up questions           ║"
-echo "  ║   • Say 'goodbye' to end session     ║"
+echo "  ║   • Say 'goodbye' to end session      ║"
 echo "  ║                                       ║"
 echo "  ║   To uninstall:                       ║"
 echo "  ║   bash ~/jarvis/uninstall.sh          ║"

install_siri_shortcut.py

@@ -1,98 +1,225 @@
 #!/usr/bin/env python3
-"""Generate and install the local macOS JARVIS Siri Shortcut.
+"""Generate and install JARVIS Siri Shortcuts for ALL Apple devices.
 
-The shortcut first ensures the JARVIS listener is running (in case it
-auto-quit after idle), then triggers the microphone command capture.
+Creates two shortcuts:
+  1. "JARVIS" — Full voice assistant. Works on iPhone, iPad, Mac, Apple Watch.
+     Say "Hey Siri, JARVIS" → asks what you need → sends to HF Space → speaks result.
+  2. "Ask JARVIS" — Quick text/voice input variant for Apple Watch.
 
-Setup: Say "Hey Siri, JARVIS" → Apple Siri activates → Shortcut fires →
-       listener starts (if needed) → mic ON → listen → respond → mic OFF.
+Flow: Siri → Shortcut → Dictate/text input → POST to JARVIS server → Speak result.
+
+Works on ALL Apple devices because it hits the cloud server (HF Space / Render),
+not localhost. The cloud server delegates macOS-specific tool calls to the
+connected Mac listener via WebSocket.
 """
 
 import plistlib
 import subprocess
 import os
+from dotenv import load_dotenv
+
+load_dotenv()
 
 JARVIS_DIR = os.path.dirname(os.path.abspath(__file__))
-TRIGGER_URL = "http://127.0.0.1:8111/trigger"
-VENV_PYTHON = os.path.join(JARVIS_DIR, "venv", "bin", "python")
-LISTENER_SCRIPT = os.path.join(JARVIS_DIR, "jarvis_listener.py")
-
-
-shortcut = {
-    "WFWorkflowMinimumClientVersionString": "900",
-    "WFWorkflowMinimumClientVersion": 900,
-    "WFWorkflowClientVersion": "2302.0.4",
-    "WFWorkflowHasShortcutInputVariables": False,
-    "WFWorkflowImportQuestions": [],
-    "WFWorkflowName": "JARVIS",
-    "WFWorkflowIcon": {
-        "WFWorkflowIconStartColor": 463140863,  # Blue
-        "WFWorkflowIconGlyphNumber": 59511,  # Microphone icon
-    },
-    "WFWorkflowTypes": [
-        "NCWidget",      # Notification Center
-        "WatchKit",      # Apple Watch
-    ],
-    "WFWorkflowInputContentItemClasses": [
-        "WFStringContentItem",
-    ],
-    "WFWorkflowActions": [
-        # ── Action 1: Set the trigger URL ──
+HF_SPACE_URL = os.getenv("HF_SPACE_URL", "https://v1deh-jarvis.hf.space")
+RENDER_URL = os.getenv("RENDER_URL", "")
+LOCAL_TRIGGER_URL = "http://127.0.0.1:8111/trigger"
+
+# Use cloud URL for cross-device, fall back to local
+JARVIS_API_URL = RENDER_URL or HF_SPACE_URL
+ASK_ENDPOINT = f"{JARVIS_API_URL}/api/ask"
+
+# Auth token for the server (if any)
+AUTH_TOKEN = os.getenv("JARVIS_AUTH_TOKEN", "")
+
+
+def build_jarvis_shortcut() -> dict:
+    """Build the main JARVIS shortcut — voice in, voice out, all Apple devices."""
+    actions = [
+        # ── Action 1: Ask for voice input ("What do you need, sir?") ──
         {
-            "WFWorkflowActionIdentifier": "is.workflow.actions.url",
+            "WFWorkflowActionIdentifier": "is.workflow.actions.ask",
             "WFWorkflowActionParameters": {
-                "WFURLActionURL": TRIGGER_URL,
+                "WFAskActionPrompt": "What do you need, sir?",
+                "WFInputType": "Text",
             },
         },
-        # ── Action 2: GET the trigger URL to wake the listener ──
+        # ── Action 2: Store the user's input ──
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.setvariable",
+            "WFWorkflowActionParameters": {
+                "WFVariableName": "UserCommand",
+            },
+        },
+        # ── Action 3: Build JSON body ──
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.gettext",
+            "WFWorkflowActionParameters": {
+                "WFTextActionText": {
+                    "Value": {
+                        "attachmentsByRange": {
+                            "{0, 1}": {
+                                "Type": "Variable",
+                                "VariableName": "UserCommand",
+                            },
+                        },
+                        "string": '{"message": "\uFFFC"}',
+                    },
+                    "WFSerializationType": "WFTextTokenString",
+                },
+            },
+        },
+        # ── Action 4: POST to JARVIS server ──
         {
             "WFWorkflowActionIdentifier": "is.workflow.actions.downloadurl",
             "WFWorkflowActionParameters": {
-                "WFHTTPMethod": "GET",
+                "WFURL": ASK_ENDPOINT,
+                "WFHTTPMethod": "POST",
+                "WFHTTPHeaders": {
+                    "Value": {
+                        "WFDictionaryFieldValueItems": [
+                            {
+                                "WFItemType": 0,
+                                "WFKey": {"Value": {"string": "Content-Type"}, "WFSerializationType": "WFTextTokenString"},
+                                "WFValue": {"Value": {"string": "application/json"}, "WFSerializationType": "WFTextTokenString"},
+                            },
+                        ] + ([
+                            {
+                                "WFItemType": 0,
+                                "WFKey": {"Value": {"string": "Authorization"}, "WFSerializationType": "WFTextTokenString"},
+                                "WFValue": {"Value": {"string": f"Bearer {AUTH_TOKEN}"}, "WFSerializationType": "WFTextTokenString"},
+                            },
+                        ] if AUTH_TOKEN else []),
+                    },
+                    "WFSerializationType": "WFDictionaryFieldValue",
+                },
+                "WFHTTPBodyType": "String",
+                "WFHTTPBodyString": {
+                    "Value": {
+                        "attachmentsByRange": {},
+                        "string": "",  # Will be set from previous action
+                    },
+                    "WFSerializationType": "WFTextTokenString",
+                },
+            },
+        },
+        # ── Action 5: Parse JSON response ──
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.detect.dictionary",
+            "WFWorkflowActionParameters": {},
+        },
+        # ── Action 6: Get "response" field from JSON ──
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.getvalueforkey",
+            "WFWorkflowActionParameters": {
+                "WFDictionaryKey": "response",
             },
         },
-    ],
-}
-
-# Write the unsigned .shortcut file (temporary)
-unsigned_path = os.path.join(JARVIS_DIR, "JARVIS-unsigned.shortcut")
-with open(unsigned_path, "wb") as f:
-    plistlib.dump(shortcut, f, fmt=plistlib.FMT_BINARY)
-
-print(f"Trigger URL: {TRIGGER_URL}")
-print()
-
-# Sign the shortcut — required by modern macOS for import.
-# "people-who-know-me" mode works without developer signing identity.
-final_path = os.path.join(JARVIS_DIR, "JARVIS.shortcut")
-try:
-    subprocess.run(
-        ["shortcuts", "sign", "-m", "people-who-know-me", "-i", unsigned_path, "-o", final_path],
-        check=True, capture_output=True,
-    )
-    os.remove(unsigned_path)
-    print(f"Signed shortcut: {final_path}")
-except Exception as e:
-    print(f"Signing failed: {e}")
-    # Fall back to unsigned (may not import on modern macOS)
-    os.rename(unsigned_path, final_path)
-    print(f"Unsigned shortcut: {final_path}")
-
-# Auto-import: try to open the shortcut directly which triggers Shortcuts app import dialog
-print()
-print("Importing shortcut into Shortcuts app...")
-try:
-    result = subprocess.run(
-        ["open", final_path],
-        capture_output=True, text=True, timeout=10,
-    )
-    if result.returncode == 0:
-        print("Shortcuts app should open with an import prompt — click 'Add Shortcut'.")
-    else:
-        print(f"Auto-import failed: {result.stderr.strip()}")
-        print(f"Manual import: open -a Shortcuts \"{final_path}\"")
-except Exception as e:
-    print(f"Auto-import error: {e}")
-
-print()
-print('After import, say "Hey Siri, JARVIS" to wake the local listener.')
+        # ── Action 7: Speak the response aloud ──
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.speaktext",
+            "WFWorkflowActionParameters": {
+                "WFSpeakTextRate": 0.45,  # Slightly faster
+                "WFSpeakTextWait": True,
+            },
+        },
+        # ── Action 8: Also show as notification ──
+        {
+            "WFWorkflowActionIdentifier": "is.workflow.actions.notification",
+            "WFWorkflowActionParameters": {
+                "WFNotificationActionTitle": "J.A.R.V.I.S.",
+            },
+        },
+    ]
+
+    # Also try to trigger local Mac listener (best-effort, won't fail on mobile)
+    actions.append({
+        "WFWorkflowActionIdentifier": "is.workflow.actions.downloadurl",
+        "WFWorkflowActionParameters": {
+            "WFURL": LOCAL_TRIGGER_URL,
+            "WFHTTPMethod": "GET",
+        },
+    })
+
+    return {
+        "WFWorkflowMinimumClientVersionString": "900",
+        "WFWorkflowMinimumClientVersion": 900,
+        "WFWorkflowClientVersion": "2302.0.4",
+        "WFWorkflowHasShortcutInputVariables": False,
+        "WFWorkflowImportQuestions": [],
+        "WFWorkflowName": "JARVIS",
+        "WFWorkflowIcon": {
+            "WFWorkflowIconStartColor": 463140863,  # Blue
+            "WFWorkflowIconGlyphNumber": 59511,      # Microphone icon
+        },
+        "WFWorkflowTypes": [
+            "NCWidget",      # Notification Center
+            "WatchKit",      # Apple Watch
+        ],
+        "WFWorkflowInputContentItemClasses": [
+            "WFStringContentItem",
+        ],
+        "WFWorkflowActions": actions,
+    }
+
+
+def sign_and_install(shortcut_data: dict, name: str):
+    """Sign and install a shortcut."""
+    unsigned_path = os.path.join(JARVIS_DIR, f"{name}-unsigned.shortcut")
+    final_path = os.path.join(JARVIS_DIR, f"{name}.shortcut")
+
+    with open(unsigned_path, "wb") as f:
+        plistlib.dump(shortcut_data, f, fmt=plistlib.FMT_BINARY)
+
+    # Sign the shortcut
+    try:
+        subprocess.run(
+            ["shortcuts", "sign", "-m", "people-who-know-me",
+             "-i", unsigned_path, "-o", final_path],
+            check=True, capture_output=True,
+        )
+        os.remove(unsigned_path)
+        print(f"  ✓ Signed: {final_path}")
+    except Exception as e:
+        print(f"  [!] Signing failed: {e}")
+        os.rename(unsigned_path, final_path)
+        print(f"  ✓ Unsigned: {final_path}")
+
+    # Auto-import
+    try:
+        result = subprocess.run(
+            ["open", final_path],
+            capture_output=True, text=True, timeout=10,
+        )
+        if result.returncode == 0:
+            print(f"  → Shortcuts app should open — click 'Add Shortcut'")
+        else:
+            print(f"  → Manual import: open '{final_path}'")
+    except Exception as e:
+        print(f"  → Auto-import error: {e}")
+
+
+if __name__ == "__main__":
+    print(f"JARVIS Server: {JARVIS_API_URL}")
+    print(f"Ask Endpoint:  {ASK_ENDPOINT}")
+    if AUTH_TOKEN:
+        print(f"Auth Token:    {AUTH_TOKEN[:8]}...")
+    print()
+
+    print("[1/1] Building JARVIS Siri Shortcut...")
+    shortcut = build_jarvis_shortcut()
+    sign_and_install(shortcut, "JARVIS")
+
+    print()
+    print("╔═══════════════════════════════════════════╗")
+    print("║  JARVIS Works On All Apple Devices:       ║")
+    print("║                                           ║")
+    print('║  • Mac/iPhone/iPad: "Hey Siri, JARVIS"    ║')
+    print("║  • Apple Watch: Raise wrist → 'JARVIS'    ║")
+    print("║  • iPhone/iPad: PWA (Add to Home Screen)  ║")
+    print("║  • Any device: Telegram bot               ║")
+    print("║                                           ║")
+    print("║  To sync shortcut to iPhone/iPad/Watch:   ║")
+    print("║  It syncs automatically via iCloud.        ║")
+    print("║  Or AirDrop the .shortcut file.           ║")
+    print("╚═══════════════════════════════════════════╝")

jarvis_app.py

@@ -1,7 +1,8 @@
 """
 J.A.R.V.I.S. — macOS Native App with WebView UI.
 
-Shows the JARVIS web interface in a native window.
+Loads the JARVIS interface directly in a native WebKit window.
+Tries local server first, then falls back to HuggingFace Space / Render.
 No terminal. No browser. Just JARVIS.
 """
 
@@ -31,10 +32,31 @@ from AppKit import (
 from Foundation import NSObject, NSURL, NSURLRequest, NSMakeRect
 from WebKit import WKWebView, WKWebViewConfiguration, WKUserContentController
 
-JARVIS_URL = os.getenv("JARVIS_URL", "http://localhost:8000")
+JARVIS_LOCAL_URL = os.getenv("JARVIS_URL", "http://localhost:8000")
+HF_SPACE_URL = os.getenv("HF_SPACE_URL", "https://v1deh-jarvis.hf.space")
+RENDER_URL = os.getenv("RENDER_URL", "")
 JARVIS_DIR = os.path.dirname(os.path.abspath(__file__))
 
 
+def _find_server() -> str:
+    """Try local → HF Space → Render. Return first reachable URL."""
+    import httpx
+    candidates = [JARVIS_LOCAL_URL, HF_SPACE_URL]
+    if RENDER_URL:
+        candidates.append(RENDER_URL)
+
+    for url in candidates:
+        if not url:
+            continue
+        try:
+            resp = httpx.get(f"{url}/api/status", timeout=5)
+            if resp.status_code == 200:
+                return url
+        except Exception:
+            continue
+    return ""
+
+
 class AppDelegate(NSObject):
     """Main application delegate — creates the WebView window."""
 
@@ -94,17 +116,40 @@ class AppDelegate(NSObject):
         NSApp.activateIgnoringOtherApps_(True)
 
     def _load_when_ready(self):
-        """Wait for the JARVIS server to be available, then load the UI."""
+        """Find reachable server (local or HF Space) and load the UI."""
+        # Try up to 15s for local server (it may be starting), then check remotes
         import httpx
 
-        for i in range(30):
+        target_url = ""
+        for i in range(15):
             try:
-                httpx.get(f"{JARVIS_URL}/api/status", timeout=3)
+                httpx.get(f"{JARVIS_LOCAL_URL}/api/status", timeout=3)
+                target_url = JARVIS_LOCAL_URL
                 break
             except Exception:
                 time.sleep(1)
 
-        url = NSURL.URLWithString_(JARVIS_URL)
+        # Local server not up — try HF Space / Render directly
+        if not target_url:
+            target_url = _find_server()
+
+        if not target_url:
+            # Nothing reachable — show error page in WebView
+            error_html = (
+                "data:text/html,"
+                "<html><body style='background:#0a0e17;color:#e0e6ed;font-family:monospace;"
+                "display:flex;align-items:center;justify-content:center;height:100vh;"
+                "flex-direction:column;'>"
+                "<h1 style='color:#00b4d8;letter-spacing:4px;'>J.A.R.V.I.S.</h1>"
+                "<p style='color:#8899aa;margin-top:16px;'>Cannot reach any server.</p>"
+                "<p style='color:#8899aa;font-size:12px;margin-top:8px;'>"
+                "Start local: <code>python server.py</code><br>"
+                "Or set HF_SPACE_URL / RENDER_URL in .env</p>"
+                "</body></html>"
+            )
+            target_url = error_html
+
+        url = NSURL.URLWithString_(target_url)
         request = NSURLRequest.requestWithURL_(url)
         self.webview.performSelectorOnMainThread_withObject_waitUntilDone_(
             objc.selector(self.webview.loadRequest_, signature=b"v@:@"),

jarvis_listener.py

@@ -84,6 +84,81 @@ def touch_activity():
     _last_activity = time.time()
 
 
+# ─── Cached automation permission state ──────────
+_automation_granted: dict[str, bool] = {}
+
+
+def check_automation_permission(app_name: str) -> bool:
+    """Check if JARVIS has Automation permission for a given app.
+    Caches the result so macOS only prompts once per app per session."""
+    if app_name in _automation_granted:
+        return _automation_granted[app_name]
+
+    try:
+        result = subprocess.run(
+            ["osascript", "-e", f'tell application "{app_name}" to name'],
+            capture_output=True, text=True, timeout=10,
+        )
+        granted = result.returncode == 0
+        _automation_granted[app_name] = granted
+        if not granted:
+            log.warning(
+                f"Automation permission denied for {app_name}. "
+                f"Fix: System Settings → Privacy & Security → Automation → enable JARVIS for {app_name}"
+            )
+        return granted
+    except Exception as e:
+        log.warning(f"Automation permission check for {app_name} failed: {e}")
+        return False
+
+
+def request_automation_permissions():
+    """Request Automation permissions for key apps at startup.
+    macOS will show a one-time prompt per app if not already granted.
+    This must run from the JARVIS process (not Terminal) so permissions
+    are associated with the JARVIS app bundle."""
+    apps_to_request = [
+        "System Events",  # Required for UI automation, keystrokes, app control
+        "Finder",         # File operations
+        "Calendar",       # Calendar events
+        "Notes",          # Note creation
+        "Reminders",      # Reminders
+        "Mail",           # Email
+    ]
+
+    log.info("Requesting Automation permissions for key apps...")
+    for app in apps_to_request:
+        granted = check_automation_permission(app)
+        if granted:
+            log.info(f"  ✓ Automation: {app}")
+        else:
+            log.warning(f"  ✗ Automation: {app} — user must grant in System Settings")
+            notify(
+                "JARVIS — Permission Needed",
+                f"Grant Automation access for {app}: System Settings → Privacy & Security → Automation",
+            )
+            # Small delay between prompts so the user sees each one
+            time.sleep(1)
+
+    # Check Accessibility (needed for global hotkey and UI control)
+    try:
+        result = subprocess.run(
+            ["osascript", "-e",
+             'tell application "System Events" to key code 0'],
+            capture_output=True, text=True, timeout=5,
+        )
+        if result.returncode != 0:
+            log.warning("Accessibility access not granted.")
+            notify(
+                "JARVIS — Accessibility Needed",
+                "System Settings → Privacy & Security → Accessibility → enable JARVIS",
+            )
+    except Exception:
+        pass
+
+    log.info("Automation permission requests complete")
+
+
 def check_mic_permission() -> bool:
     """Test if microphone is actually returning audio data.
     macOS silently returns zeros when permission is not granted."""
@@ -495,6 +570,9 @@ EXIT_PHRASES = {"goodbye", "that's all", "thats all", "thank you", "thanks",
                 "go to sleep", "nevermind", "never mind", "bye", "dismiss"}
 CONVERSATION_TIMEOUT = 30  # seconds of silence before auto-ending session
 
+# Standby mode — mic is fully off, only hotkey/Siri/menubar can re-activate
+standby_mode = threading.Event()
+
 
 def handle_activation(command_text=None):
     """
@@ -508,6 +586,8 @@ def handle_activation(command_text=None):
         return
 
     touch_activity()
+    # Exit standby when user explicitly activates
+    standby_mode.clear()
 
     try:
         wake_pause_event.set()
@@ -532,8 +612,9 @@ def handle_activation(command_text=None):
 
             # Check if user wants to end conversation
             if command_text.lower().strip().rstrip(".!") in EXIT_PHRASES:
-                speak("Standing by, sir.")
-                log.info("Conversation ended by user")
+                speak("Standing by, sir. Mic is off.")
+                log.info("Conversation ended by user — entering standby (mic off)")
+                standby_mode.set()
                 break
 
             # Process the command
@@ -543,6 +624,12 @@ def handle_activation(command_text=None):
             speak(answer)
 
             # Listen for follow-up (with shorter timeout)
+            # If server returned an error, prompt user to retry
+            is_error = answer.startswith(("I can't reach", "The request timed out",
+                                          "I got a garbled", "I'm having trouble"))
+            if is_error:
+                speak("Would you like to try again, sir?")
+
             log.info("Listening for follow-up...")
             command_text = _listen_for_command()
             if not command_text:
@@ -643,6 +730,16 @@ def start_local_wake_listener():
         diag_max_amp = 0
 
         while True:
+            # Standby mode — mic fully off until hotkey/Siri/menubar reactivates
+            if standby_mode.is_set():
+                close_stream()
+                clear_audio_state()
+                diag_frame_count = 0
+                diag_speech_count = 0
+                diag_max_amp = 0
+                time.sleep(0.2)
+                continue
+
             if wake_pause_event.is_set():
                 close_stream()
                 clear_audio_state()
@@ -890,12 +987,10 @@ def server_watchdog():
 _device_id = None
 
 
-def device_heartbeat_loop():
-    """Send periodic heartbeats to the server so the device shows as online."""
+def _load_device_id():
+    """Load or generate a persistent device ID."""
     global _device_id
     device_id_file = os.path.join(JARVIS_DIR, ".device_id")
-
-    # Load or generate device ID
     if os.path.exists(device_id_file):
         with open(device_id_file) as f:
             _device_id = f.read().strip()
@@ -904,12 +999,17 @@ def device_heartbeat_loop():
         _device_id = str(uuid.uuid4())[:12]
         with open(device_id_file, "w") as f:
             f.write(_device_id)
+    return _device_id
+
 
+def device_heartbeat_loop():
+    """Send periodic heartbeats to the server so the device shows as online."""
+    _load_device_id()
     log.info(f"Device heartbeat: ID={_device_id}, interval=60s")
     while True:
         try:
             httpx.post(
-                f"{JARVIS_URL}/api/device/heartbeat",
+                f"{JARVIS_URL}/api/devices/heartbeat",
                 json={"device_id": _device_id},
                 timeout=5,
             )
@@ -918,6 +1018,96 @@ def device_heartbeat_loop():
         time.sleep(60)
 
 
+def device_websocket_loop():
+    """Connect to server via WebSocket to receive delegated tool commands in real-time.
+
+    When the JARVIS server runs on HF Space (Linux), macOS-only tools like
+    open_app, set_volume, spotify_play, etc. get delegated to this connected
+    device for local execution.
+    """
+    import websocket as ws_client
+
+    _load_device_id()
+    ws_url = JARVIS_URL.replace("http://", "ws://").replace("https://", "wss://")
+    endpoint = f"{ws_url}/ws/device/{_device_id}"
+
+    def _execute_tool_locally(tool_name: str, tool_args: dict) -> str:
+        """Execute a tool on this Mac and return the result."""
+        try:
+            # Import tool registry (already loaded by server.py imports,
+            # but listener runs standalone so we import directly)
+            sys.path.insert(0, JARVIS_DIR)
+            from tools import TOOL_REGISTRY, execute_tool as _exec
+            import tools.builtin
+            import tools.system_control
+            import tools.app_automation
+            import tools.vscode_tools
+            import tools.device_control
+
+            if tool_name not in TOOL_REGISTRY:
+                return f"Error: Unknown tool '{tool_name}'"
+
+            func = TOOL_REGISTRY[tool_name]["function"]
+            result = func(**tool_args)
+            # Handle async tools
+            if hasattr(result, "__await__"):
+                import asyncio
+                loop = asyncio.new_event_loop()
+                result = loop.run_until_complete(result)
+                loop.close()
+            return str(result)
+        except Exception as e:
+            log.error(f"Local tool execution failed: {tool_name}({tool_args}) -> {e}")
+            return f"Error: {e}"
+
+    while True:
+        try:
+            log.info(f"Device WS: connecting to {endpoint}")
+            ws = ws_client.WebSocket()
+            ws.connect(endpoint, timeout=10)
+            log.info(f"Device WS: connected as {_device_id}")
+
+            while True:
+                msg = ws.recv()
+                if not msg:
+                    continue
+                data = json.loads(msg)
+
+                if data.get("type") == "command" and data.get("action") == "execute_tool":
+                    tool_name = data.get("tool", "")
+                    tool_args = data.get("args", {})
+                    log.info(f"Device WS: executing delegated tool {tool_name}({tool_args})")
+                    notify("JARVIS — Remote Command", f"Executing: {tool_name}")
+
+                    result = _execute_tool_locally(tool_name, tool_args)
+                    log.info(f"Device WS: {tool_name} result: {result[:200]}")
+
+                    # Report result back to server
+                    cmd_id = data.get("cmd_id", "")
+                    if cmd_id:
+                        ws.send(json.dumps({
+                            "type": "command_result",
+                            "cmd_id": cmd_id,
+                            "result": result,
+                        }))
+                    notify("JARVIS", f"{tool_name}: {result[:100]}")
+
+                elif data.get("type") == "command":
+                    # Generic command (not a tool call) — speak it
+                    command_text = data.get("command", "")
+                    if command_text:
+                        log.info(f"Device WS: received command: {command_text}")
+                        threading.Thread(
+                            target=handle_activation,
+                            kwargs={"command_text": command_text},
+                            daemon=True,
+                        ).start()
+
+        except Exception as e:
+            log.warning(f"Device WS: connection lost ({e}), reconnecting in 10s...")
+            time.sleep(10)
+
+
 # ─── Clap/Snap Detection ─────────────────────────
 def start_clap_detector():
     """Start clap/snap detection as an additional wake trigger."""
@@ -975,17 +1165,44 @@ def run_menubar():
             self.title = "J"
             self.menu = [
                 rumps.MenuItem("Activate JARVIS", callback=self.on_activate),
+                rumps.MenuItem("Resume Listening", callback=self.on_resume),
                 None,
                 rumps.MenuItem("Status", callback=self.on_status),
                 None,
                 rumps.MenuItem("Quit", callback=self.on_quit),
             ]
+            # Monitor standby mode to update menu bar title
+            threading.Thread(target=self._watch_standby, daemon=True).start()
+
+        def _watch_standby(self):
+            """Update menu bar icon when entering/leaving standby."""
+            was_standby = False
+            while True:
+                is_standby = standby_mode.is_set()
+                if is_standby and not was_standby:
+                    self.title = "J💤"
+                    log.info("Menu bar: standby mode (mic off)")
+                elif not is_standby and was_standby:
+                    self.title = "J"
+                    log.info("Menu bar: active mode")
+                was_standby = is_standby
+                time.sleep(1)
 
         def on_activate(self, _):
             touch_activity()
+            standby_mode.clear()  # Exit standby on manual activation
             threading.Thread(target=handle_activation, daemon=True).start()
             rumps.notification("J.A.R.V.I.S.", "", "Listening...", sound=False)
 
+        def on_resume(self, _):
+            """Resume wake word listening after standby."""
+            if standby_mode.is_set():
+                standby_mode.clear()
+                rumps.notification("J.A.R.V.I.S.", "", "Wake word listening resumed", sound=True)
+                speak("I'm back online, sir.")
+            else:
+                rumps.notification("J.A.R.V.I.S.", "", "Already listening", sound=False)
+
         def on_status(self, _):
             threading.Thread(target=self._check_status, daemon=True).start()
 
@@ -998,6 +1215,7 @@ def run_menubar():
                 parts.append("Server: offline")
             parts.append(f"Wake: {ACTIVE_WAKE_MODE}")
             parts.append(f"Clap: {'on' if ENABLE_CLAP_DETECTION else 'off'}")
+            parts.append(f"Mic: {'off (standby)' if standby_mode.is_set() else 'active'}")
             rumps.notification("J.A.R.V.I.S. Status", "", " | ".join(parts))
 
         def on_quit(self, _):
@@ -1045,12 +1263,18 @@ def main():
     threading.Thread(target=start_hotkey_listener, daemon=True).start()
     threading.Thread(target=server_watchdog, daemon=True).start()
     threading.Thread(target=device_heartbeat_loop, daemon=True).start()
+    threading.Thread(target=device_websocket_loop, daemon=True).start()
 
     # Check mic permission before starting wake word listeners
     mic_ok = check_mic_permission()
     if not mic_ok:
         log.warning("Mic check returned silent — will attempt wake listeners anyway (TCC may grant access to .app bundle)")
 
+    # Request Automation/Accessibility permissions at startup
+    # This triggers macOS permission prompts from the JARVIS process
+    # so permissions are associated with the JARVIS app bundle
+    threading.Thread(target=request_automation_permissions, daemon=True).start()
+
     if ACTIVE_WAKE_MODE == "local":
         threading.Thread(target=start_local_wake_listener, daemon=True).start()
 

server.py

@@ -33,7 +33,7 @@ load_dotenv()
 from memory import Memory
 from llm import SYSTEM_PROMPT, stream_response, get_active_backend, get_available_backends, FREE_MODELS, HF_FREE_MODELS
 from stm import apply_stm, AutoTune
-from tools import get_tools_prompt, execute_tool, TOOL_REGISTRY
+from tools import get_tools_prompt, execute_tool, TOOL_REGISTRY, register_macos_tools
 import tools.builtin  # Register built-in tools
 import tools.system_control  # System control tools
 import tools.user_tools  # User profile, routines, work sessions
@@ -43,6 +43,9 @@ import tools.app_automation  # Deep app control (Spotify, Notes, Calendar, Mail,
 import tools.device_onboarding  # User device registration & cross-device commands
 from user_profile import get_user_context, get_preferences, get_today_routine, get_work_history, get_active_work_session
 
+# Tag macOS-only tools so they get delegated to connected devices on Linux (HF Space)
+register_macos_tools()
+
 # ── Auth Token ────────────────────────────────────────────────────
 # Set JARVIS_AUTH_TOKEN in .env for a fixed token; otherwise a random one is
 # generated each startup and printed to the console.

static/index.html

@@ -2,14 +2,21 @@
 <html lang="en">
 <head>
     <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover">
     <meta name="apple-mobile-web-app-capable" content="yes">
     <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
     <meta name="apple-mobile-web-app-title" content="JARVIS">
     <meta name="mobile-web-app-capable" content="yes">
     <meta name="theme-color" content="#0a0e17">
+    <meta name="format-detection" content="telephone=no">
     <link rel="manifest" href="/static/manifest.json">
-    <link rel="apple-touch-icon" href="/static/icon-192.png">
+    <!-- Apple touch icons for iPhone / iPad -->
+    <link rel="apple-touch-icon" href="/static/apple-touch-icon.png">
+    <link rel="apple-touch-icon" sizes="152x152" href="/static/apple-touch-icon-152.png">
+    <link rel="apple-touch-icon" sizes="167x167" href="/static/apple-touch-icon-167.png">
+    <link rel="apple-touch-icon" sizes="180x180" href="/static/apple-touch-icon.png">
+    <!-- iOS splash screens -->
+    <meta name="apple-mobile-web-app-orientations" content="portrait">
     <title>J.A.R.V.I.S.</title>
     <style>
         * { margin: 0; padding: 0; box-sizing: border-box; }
@@ -482,6 +489,22 @@
             .welcome h2 { font-size: 20px; }
             .quick-actions { gap: 6px; }
         }
+
+        /* iOS safe areas — notch / Dynamic Island / home indicator */
+        @supports (padding-top: env(safe-area-inset-top)) {
+            .header {
+                padding-top: calc(12px + env(safe-area-inset-top));
+            }
+            .input-area {
+                padding-bottom: calc(16px + env(safe-area-inset-bottom));
+            }
+        }
+
+        /* iPad specific — wider layout */
+        @media (min-width: 768px) and (max-width: 1024px) {
+            .message { max-width: 75%; }
+            .input-row { max-width: 700px; }
+        }
     </style>
 </head>
 <body>
@@ -1159,28 +1182,41 @@
             deferredPrompt = null;
         }
 
-        // iOS install hint
+        // iOS / iPadOS install hint
         function checkiOSInstall() {
-            const isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent);
+            const isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent) ||
+                          (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1); // iPad with desktop UA
             const isStandalone = window.navigator.standalone;
-            if (isIOS && !isStandalone) {
+            const dismissed = localStorage.getItem('jarvis_ios_install_dismissed');
+            if (isIOS && !isStandalone && !dismissed) {
+                const isIPad = /iPad/.test(navigator.userAgent) ||
+                               (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1);
+                const deviceName = isIPad ? 'iPad' : 'iPhone';
                 const hint = document.createElement('div');
+                hint.id = 'ios-install-hint';
                 hint.style.cssText = `
                     position: fixed; bottom: 80px; left: 50%; transform: translateX(-50%);
                     background: var(--surface2); border: 1px solid var(--accent);
-                    border-radius: 16px; padding: 12px 20px; z-index: 1000;
+                    border-radius: 16px; padding: 16px 24px; z-index: 1000;
                     box-shadow: 0 0 30px var(--accent-glow); animation: fadeIn 0.5s ease;
-                    max-width: 90vw; text-align: center; font-size: 12px; color: var(--text);
+                    max-width: 90vw; text-align: center; font-size: 13px; color: var(--text);
                 `;
                 hint.innerHTML = `
-                    <div style="margin-bottom:6px; font-weight:bold; color: var(--accent);">Install JARVIS</div>
-                    Tap <span style="font-size:16px;">&#9769;</span> Share → <strong>Add to Home Screen</strong>
-                    <br><span style="color: var(--text2); font-size:10px;">Then it works like a real app — no browser needed</span>
-                    <br><button onclick="this.parentElement.remove()" style="
-                        margin-top:8px; background:none; border:1px solid var(--accent);
-                        color:var(--accent); padding:4px 12px; border-radius:8px;
-                        font-family:inherit; font-size:11px; cursor:pointer;
-                    ">GOT IT</button>
+                    <div style="margin-bottom:8px; font-weight:bold; color: var(--accent); font-size:15px;">Install JARVIS on ${deviceName}</div>
+                    <div style="margin-bottom:6px;">Tap <svg width="16" height="16" viewBox="0 0 24 24" fill="currentColor" style="vertical-align:middle;"><path d="M16 5l-1.42 1.42-1.59-1.59V16h-1.98V4.83L9.42 6.42 8 5l4-4 4 4zm4 5v11c0 1.1-.9 2-2 2H6c-1.11 0-2-.9-2-2V10c0-1.11.89-2 2-2h3v2H6v11h12V10h-3V8h3c1.1 0 2 .89 2 2z"/></svg> Share → <strong>Add to Home Screen</strong></div>
+                    <div style="color: var(--text2); font-size:11px; margin-bottom:10px;">JARVIS will run like a native app — fullscreen, with mic &amp; voice</div>
+                    <div style="display:flex; gap:8px; justify-content:center;">
+                        <button onclick="this.closest('#ios-install-hint').remove()" style="
+                            background:none; border:1px solid var(--accent);
+                            color:var(--accent); padding:6px 16px; border-radius:10px;
+                            font-family:inherit; font-size:12px; cursor:pointer;
+                        ">GOT IT</button>
+                        <button onclick="localStorage.setItem('jarvis_ios_install_dismissed','1'); this.closest('#ios-install-hint').remove()" style="
+                            background:none; border:1px solid var(--text2);
+                            color:var(--text2); padding:6px 16px; border-radius:10px;
+                            font-family:inherit; font-size:11px; cursor:pointer;
+                        ">DON'T SHOW AGAIN</button>
+                    </div>
                 `;
                 document.body.appendChild(hint);
             }

static/manifest.json

@@ -1,13 +1,32 @@
 {
   "name": "J.A.R.V.I.S.",
   "short_name": "JARVIS",
-  "description": "Just A Rather Very Intelligent System",
+  "description": "Just A Rather Very Intelligent System — Your AI Assistant",
   "start_url": "/",
   "display": "standalone",
   "background_color": "#0a0e17",
   "theme_color": "#00b4d8",
   "orientation": "portrait",
+  "scope": "/",
   "icons": [
+    {
+      "src": "/static/apple-touch-icon-152.png",
+      "sizes": "152x152",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "/static/apple-touch-icon-167.png",
+      "sizes": "167x167",
+      "type": "image/png",
+      "purpose": "any"
+    },
+    {
+      "src": "/static/apple-touch-icon.png",
+      "sizes": "180x180",
+      "type": "image/png",
+      "purpose": "any"
+    },
     {
       "src": "/static/icon-192.png",
       "sizes": "192x192",

static/sw.js

@@ -1,6 +1,14 @@
 // JARVIS Service Worker — enables offline + PWA install
-const CACHE_NAME = 'jarvis-v1';
-const ASSETS = ['/', '/static/manifest.json', '/static/icon-192.png', '/static/icon-512.png'];
+const CACHE_NAME = 'jarvis-v2';
+const ASSETS = [
+  '/',
+  '/static/manifest.json',
+  '/static/icon-192.png',
+  '/static/icon-512.png',
+  '/static/apple-touch-icon.png',
+  '/static/apple-touch-icon-152.png',
+  '/static/apple-touch-icon-167.png',
+];
 
 self.addEventListener('install', (event) => {
   event.waitUntil(

tests/test_app_automation.py

@@ -161,20 +161,28 @@ class TestRemindersTools(unittest.TestCase):
 
 class TestCalendarTools(unittest.TestCase):
 
+    @patch("tools.app_automation._check_calendar_permission", return_value=True)
     @patch("tools.app_automation._osascript")
-    def test_calendar_today(self, mock_osascript):
+    def test_calendar_today(self, mock_osascript, mock_perm):
         mock_osascript.return_value = "• 10:00 AM — Team Standup\n• 2:00 PM — Design Review"
         from tools.app_automation import calendar_today
         result = calendar_today()
         self.assertIn("Standup", result)
 
+    @patch("tools.app_automation._check_calendar_permission", return_value=True)
     @patch("tools.app_automation._osascript")
-    def test_calendar_create_event(self, mock_osascript):
+    def test_calendar_create_event(self, mock_osascript, mock_perm):
         mock_osascript.return_value = "Event created: Lunch"
         from tools.app_automation import calendar_create_event
         result = calendar_create_event("Lunch", "2026-04-07 12:00", "2026-04-07 13:00", location="Cafe")
         self.assertIn("Event created", result)
 
+    @patch("tools.app_automation._check_calendar_permission", return_value=False)
+    def test_calendar_permission_denied(self, mock_perm):
+        from tools.app_automation import calendar_today
+        result = calendar_today()
+        self.assertIn("Calendar access not granted", result)
+
 
 class TestBrowserTools(unittest.TestCase):
 
@@ -289,6 +297,46 @@ class TestUniversalAppControl(unittest.TestCase):
         self.assertIn("Times Square", result)
 
 
+class TestOpenAppAliases(unittest.TestCase):
+    """Test open_app resolves common aliases to correct macOS app names."""
+
+    @patch("tools.builtin.subprocess.run")
+    def test_camera_alias(self, mock_run):
+        mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+        from tools.builtin import open_app
+        result = open_app("camera")
+        self.assertIn("FaceTime", result)
+        mock_run.assert_called_once_with(
+            ["open", "-a", "FaceTime"],
+            capture_output=True, text=True, timeout=10,
+        )
+
+    @patch("tools.builtin.subprocess.run")
+    def test_vscode_alias(self, mock_run):
+        mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+        from tools.builtin import open_app
+        result = open_app("vscode")
+        self.assertIn("Visual Studio Code", result)
+
+    @patch("tools.builtin.subprocess.run")
+    def test_direct_name_passthrough(self, mock_run):
+        mock_run.return_value = MagicMock(returncode=0, stdout="", stderr="")
+        from tools.builtin import open_app
+        result = open_app("Safari")
+        self.assertIn("Safari", result)
+
+    @patch("tools.builtin.subprocess.run")
+    def test_permission_error_message(self, mock_run):
+        mock_run.return_value = MagicMock(
+            returncode=1,
+            stdout="",
+            stderr="Not allowed to send Apple events",
+        )
+        from tools.builtin import open_app
+        result = open_app("Notes")
+        self.assertIn("Automation permission", result)
+
+
 class TestTotalToolCount(unittest.TestCase):
     """Ensure total tools meets target after all modules loaded."""
 

tools/__init__.py

@@ -1,13 +1,25 @@
 """JARVIS Tool System — extensible tool registry."""
 
 import json
+import platform
 from typing import Callable
 
 TOOL_REGISTRY: dict[str, dict] = {}
 
+# Tools that require macOS (osascript/subprocess) and should be delegated
+# to a connected device when the server runs on Linux (HF Space / Render).
+_MACOS_ONLY_TOOLS: set[str] = set()
 
-def tool(name: str, description: str, parameters: dict = None):
-    """Decorator to register a tool."""
+IS_MACOS = platform.system() == "Darwin"
+
+
+def tool(name: str, description: str, parameters: dict = None, macos_only: bool = False):
+    """Decorator to register a tool.
+
+    Args:
+        macos_only: If True, this tool requires macOS (osascript, AppleScript, etc.)
+                    and will be delegated to a connected device when running on Linux.
+    """
     def decorator(func: Callable):
         TOOL_REGISTRY[name] = {
             "name": name,
@@ -15,13 +27,69 @@ def tool(name: str, description: str, parameters: dict = None):
             "parameters": parameters or {},
             "function": func,
         }
+        if macos_only:
+            _MACOS_ONLY_TOOLS.add(name)
         return func
     return decorator
 
 
+async def _delegate_to_device(name: str, args: dict) -> str:
+    """Delegate a macOS-only tool call to a connected device via WebSocket push."""
+    try:
+        from user_device_registry import list_devices, send_command_to_device
+    except ImportError:
+        return f"Error: {name} requires macOS but this server runs on Linux. No device delegation available."
+
+    # Find an online device to delegate to
+    devices = await list_devices("default")
+    online_devices = [d for d in devices if d.get("status") == "online"]
+    if not online_devices:
+        return (
+            f"Error: '{name}' requires macOS but this server runs in the cloud. "
+            f"No connected Mac device found to execute this command. "
+            f"Make sure the JARVIS listener is running on your Mac."
+        )
+
+    target = online_devices[0]
+    device_id = target.get("device_id", "")
+    alias = target.get("alias", "device")
+
+    # Try WebSocket push first (instant)
+    try:
+        # Import at call time to avoid circular imports
+        import importlib
+        server_mod = importlib.import_module("server")
+        push_fn = getattr(server_mod, "push_command_to_device", None)
+        if push_fn:
+            pushed = await push_fn(device_id, {
+                "action": "execute_tool",
+                "tool": name,
+                "args": args,
+            })
+            if pushed:
+                return f"Command '{name}' sent to {alias} for execution."
+    except Exception:
+        pass
+
+    # Fallback: queue command via REST
+    result = await send_command_to_device(
+        target_alias=alias,
+        command=json.dumps({"tool": name, "args": args}),
+        user_id="default",
+    )
+    if "error" in result:
+        return f"Error delegating '{name}' to {alias}: {result['error']}"
+    return f"Command '{name}' queued for execution on {alias}."
+
+
 async def execute_tool(name: str, args: dict) -> str:
     if name not in TOOL_REGISTRY:
         return f"Error: Unknown tool '{name}'"
+
+    # If running on Linux (HF Space) and this tool needs macOS, delegate it
+    if not IS_MACOS and name in _MACOS_ONLY_TOOLS:
+        return await _delegate_to_device(name, args)
+
     try:
         result = TOOL_REGISTRY[name]["function"](**args)
         if hasattr(result, "__await__"):
@@ -33,6 +101,48 @@ async def execute_tool(name: str, args: dict) -> str:
         return f"Error executing {name}: {type(e).__name__}"
 
 
+def register_macos_tools():
+    """Register all macOS-only tool names.
+
+    Called after all tool modules are imported so TOOL_REGISTRY is populated.
+    These tools use osascript, AppleScript, or macOS-specific CLI commands.
+    On Linux (HF Space / Render), they get automatically delegated to a
+    connected Mac device via WebSocket push.
+    """
+    macos_tools = {
+        # system_control.py — all 22 tools
+        "set_volume", "get_volume", "set_brightness", "toggle_dark_mode",
+        "wifi_control", "bluetooth_control", "do_not_disturb", "screenshot",
+        "media_control", "clipboard", "send_notification", "list_running_apps",
+        "quit_app", "set_timer", "lock_screen", "sleep_display", "empty_trash",
+        "announce", "open_url", "search_files", "create_reminder", "get_events",
+        # app_automation.py — all 36 tools
+        "spotify_play", "spotify_play_uri", "spotify_search", "spotify_queue",
+        "spotify_status", "spotify_control",
+        "notes_create", "notes_append", "notes_list", "notes_search",
+        "notes_read", "notes_delete",
+        "reminders_add", "reminders_list", "reminders_complete",
+        "calendar_create_event", "calendar_today",
+        "send_imessage", "read_messages",
+        "mail_compose", "mail_unread",
+        "browser_open", "browser_tabs", "browser_read_page",
+        "spotlight_search", "finder_open", "finder_move", "finder_copy", "trash_file",
+        "contacts_search", "maps_directions",
+        "app_keystroke", "app_menu_click", "app_window_manage", "textedit_create",
+        # builtin.py — macOS-specific subset
+        "open_app", "open_terminal",
+        # vscode_tools.py — all 7 tools
+        "vscode_open", "vscode_open_terminal", "vscode_run_command",
+        "copilot_chat", "copilot_inline", "vscode_list_extensions", "vscode_diff",
+        # device_control.py — macOS-specific subset
+        "bluetooth_scan", "bluetooth_pair", "bluetooth_connect",
+        "bluetooth_disconnect", "bluetooth_info", "network_scan",
+        "bonjour_discover", "homekit_control", "homekit_list_shortcuts",
+        "find_my_devices", "siri_command", "airdrop_file",
+    }
+    _MACOS_ONLY_TOOLS.update(macos_tools)
+
+
 def get_tool_definitions() -> list[dict]:
     """Get tool definitions formatted for LLM function calling."""
     tools = []

tools/app_automation.py

@@ -44,6 +44,10 @@ def _osascript(script: str, timeout: int = 15) -> str:
     out = result.stdout.strip()
     if result.returncode != 0 and result.stderr.strip():
         err = result.stderr.strip()
+        if "not allowed assistive access" in err.lower() or "not allowed to send keystrokes" in err.lower():
+            return ("Error: JARVIS needs Automation/Accessibility permission. "
+                    "Go to System Settings → Privacy & Security → Automation and enable JARVIS, "
+                    "then also check Accessibility.")
         if "execution error" in err.lower():
             return f"Error: {err}"
     return out
@@ -605,6 +609,26 @@ def reminders_complete(title: str) -> str:
 #  APPLE CALENDAR
 # ═══════════════════════════════════════════════════════════════
 
+# Cache so Calendar permission is only checked once per session
+_calendar_permission_checked = False
+_calendar_permission_granted = False
+
+
+def _check_calendar_permission() -> bool:
+    """Check Calendar automation permission once; cache the result."""
+    global _calendar_permission_checked, _calendar_permission_granted
+    if _calendar_permission_checked:
+        return _calendar_permission_granted
+    _calendar_permission_checked = True
+    result = subprocess.run(
+        ["osascript", "-e", 'tell application "Calendar" to name'],
+        capture_output=True, text=True, timeout=10,
+    )
+    _calendar_permission_granted = result.returncode == 0
+    if not _calendar_permission_granted:
+        _calendar_permission_granted = False
+    return _calendar_permission_granted
+
 
 @tool(
     name="calendar_create_event",
@@ -625,6 +649,9 @@ def reminders_complete(title: str) -> str:
 def calendar_create_event(title: str, start_date: str, end_date: str,
                            location: str = "", notes: str = "",
                            calendar_name: str = "") -> str:
+    if not _check_calendar_permission():
+        return ("Error: Calendar access not granted. Go to System Settings → Privacy & Security → "
+                "Automation and allow JARVIS to control Calendar.")
     safe_title = title.replace('"', '\\"')
     safe_loc = location.replace('"', '\\"')
     safe_notes = notes.replace('"', '\\"')
@@ -654,6 +681,9 @@ def calendar_create_event(title: str, start_date: str, end_date: str,
     parameters={"type": "object", "properties": {}},
 )
 def calendar_today() -> str:
+    if not _check_calendar_permission():
+        return ("Error: Calendar access not granted. Go to System Settings → Privacy & Security → "
+                "Automation and allow JARVIS to control Calendar.")
     result = _osascript('''
         set todayStart to current date
         set time of todayStart to 0

tools/builtin.py

@@ -367,21 +367,52 @@ def open_app(app_name: str) -> str:
     system = platform.system()
     try:
         if system == "Darwin":
-            # Primary: use macOS `open -a`
+            # Map common aliases to actual macOS app names
+            app_aliases = {
+                "camera": "FaceTime",
+                "photo booth": "Photo Booth",
+                "facetime": "FaceTime",
+                "vscode": "Visual Studio Code",
+                "vs code": "Visual Studio Code",
+                "chrome": "Google Chrome",
+                "word": "Microsoft Word",
+                "excel": "Microsoft Excel",
+                "powerpoint": "Microsoft PowerPoint",
+                "teams": "Microsoft Teams",
+                "outlook": "Microsoft Outlook",
+                "code": "Visual Studio Code",
+                "iterm": "iTerm",
+                "terminal": "Terminal",
+            }
+            resolved_name = app_aliases.get(app_name.lower(), app_name)
+
+            # Primary: use macOS `open -a` (no Automation permission needed)
             result = subprocess.run(
-                ["open", "-a", app_name],
+                ["open", "-a", resolved_name],
                 capture_output=True, text=True, timeout=10,
             )
             if result.returncode == 0:
-                return f"Opened {app_name}"
+                return f"Opened {resolved_name}"
+            # Retry with original name if alias didn't work
+            if resolved_name != app_name:
+                result2 = subprocess.run(
+                    ["open", "-a", app_name],
+                    capture_output=True, text=True, timeout=10,
+                )
+                if result2.returncode == 0:
+                    return f"Opened {app_name}"
             # Fallback: AppleScript activate (handles apps `open -a` can't find)
             fallback = subprocess.run(
-                ["osascript", "-e", f'tell application "{app_name}" to activate'],
+                ["osascript", "-e", f'tell application "{resolved_name}" to activate'],
                 capture_output=True, text=True, timeout=10,
             )
             if fallback.returncode == 0:
-                return f"Opened {app_name}"
-            return f"Error opening {app_name}: {result.stderr.strip() or fallback.stderr.strip()}"
+                return f"Opened {resolved_name}"
+            err_msg = result.stderr.strip() or fallback.stderr.strip()
+            if "not allowed" in err_msg.lower():
+                return (f"Error opening {app_name}: JARVIS needs Automation permission. "
+                        "Go to System Settings → Privacy & Security → Automation and enable JARVIS.")
+            return f"Error opening {app_name}: {err_msg}"
         elif system == "Linux":
             subprocess.Popen([app_name])
         elif system == "Windows":

uninstall.sh

@@ -23,7 +23,12 @@ sleep 1
 # ─── Remove JARVIS .app bundles ───
 rm -rf "$HOME/jarvis/JARVIS-Listener.app"
 rm -rf "/Applications/JARVIS Listener.app"
-rm -rf "/Applications/JARVIS.app"
+if [ -d "/Applications/JARVIS.app" ]; then
+    sudo rm -rf "/Applications/JARVIS.app" 2>/dev/null || {
+        echo "  [!] Could not remove /Applications/JARVIS.app (need admin password)"
+        echo "  [!] Run: sudo rm -rf /Applications/JARVIS.app"
+    }
+fi
 
 # ─── Remove the Siri Shortcut ───
 # Delete the generated shortcut file
@@ -68,16 +73,16 @@ rm -rf "$HOME/jarvis/tools/__pycache__"
 tccutil reset Microphone ai.jarvis.listener 2>/dev/null || true
 
 echo ""
-echo "  ╔═══════════════════════════════════════╗"
-echo "  ║   J.A.R.V.I.S. UNINSTALLED           ║"
-echo "  ║                                       ║"
-echo "  ║   ✓ Services stopped & removed        ║"
-echo "  ║   ✓ Mac apps removed                  ║"
-echo "  ║   ✓ Siri Shortcut removed             ║"
-echo "  ║   ✓ Log files cleaned                 ║"
-echo "  ║   ✓ Build artifacts removed            ║"
-echo "  ║                                       ║"
-echo "  ║   Source code preserved at ~/jarvis/   ║"
+echo "  ╔═════════════════════════════════════════╗"
+echo "  ║   J.A.R.V.I.S. UNINSTALLED              ║"
+echo "  ║                                         ║"
+echo "  ║   ✓ Services stopped & removed          ║"
+echo "  ║   ✓ Mac apps removed                    ║"
+echo "  ║   ✓ Siri Shortcut removed               ║"
+echo "  ║   ✓ Log files cleaned                   ║"
+echo "  ║   ✓ Build artifacts removed             ║"
+echo "  ║                                         ║"
+echo "  ║   Source code preserved at ~/jarvis/    ║"
 echo "  ║   To reinstall: bash ~/jarvis/install.sh║"
-echo "  ╚═══════════════════════════════════════╝"
+echo "  ╚═════════════════════════════════════════╝"
 echo ""