grok-assistant 1.0__py3-none-any.whl

grok_assistant/__init__.py

@@ -0,0 +1,4 @@
+"""A voice assistant that listens at home and bothers the cloud on purpose."""
+
+__version__ = "1.0"
+__release__ = "v1.0-rc.2"

grok_assistant/__main__.py

@@ -0,0 +1,110 @@
+"""Grok Assistant, the PC body of the experiment."""
+
+from __future__ import annotations
+
+import faulthandler
+import sys
+import tempfile
+import traceback
+from pathlib import Path
+
+from grok_assistant.paths import bundle_root, default_data_dir, load_lines
+
+_FAULT_LOG = None
+
+
+def main(argv: list[str] | None = None) -> None:
+    try:
+        folder = default_data_dir()
+        folder.mkdir(parents=True, exist_ok=True)
+        crash = folder / "crash.log"
+        # The file has to stay referenced or a later native fault has nowhere to land.
+        global _FAULT_LOG
+        _FAULT_LOG = crash.open("a", encoding="utf-8")
+        faulthandler.enable(_FAULT_LOG, all_threads=True)
+    except OSError:
+        pass
+    try:
+        _main(argv)
+    except Exception:
+        path = _crash_log()
+        _tell_crash(path)
+        raise SystemExit(1)
+
+
+def _main(argv: list[str] | None) -> None:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if "--check" in args:
+        _write_check()
+        return
+    if "--console" in args:
+        from grok_assistant.console import run
+        run()
+        return
+    from grok_assistant.cloud.setup_grok import ensure_grok
+    from grok_assistant.ui.app import run
+
+    ensure_grok()
+    run()
+
+
+def _crash_log() -> Path:
+    folder = default_data_dir()
+    folder.mkdir(parents=True, exist_ok=True)
+    path = folder / "crash.log"
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(traceback.format_exc())
+        handle.write("\n")
+    return path
+
+
+def _tell_crash(path: Path) -> None:
+    try:
+        import tkinter as tk
+        from tkinter import messagebox
+
+        root = tk.Tk()
+        root.withdraw()
+        messagebox.showerror("Grok Assistant", f"Se cerró por un error.\n{path}")
+        root.destroy()
+    except Exception:
+        return
+
+
+def _importable(name: str) -> bool:
+    try:
+        __import__(name)
+    except Exception:
+        return False
+    return True
+
+
+def _kroko_ready() -> bool:
+    from grok_assistant.listening.kroko_ear import kroko_dir
+
+    return kroko_dir() is not None
+
+
+def _write_check() -> None:
+    from grok_assistant import __version__
+    from grok_assistant.cloud.grok_cli import GrokCLI
+    from grok_assistant.cloud.setup_grok import probe
+
+    status = probe()
+    lines = [
+        f"version={__version__}",
+        "channel=release-candidate",
+        f"hellos={len(load_lines('hellos-es.txt'))}",
+        f"scripts={(bundle_root() / 'scripts' / 'speak.ps1').exists()}",
+        f"listeners={(bundle_root() / 'listeners' / 'dictation.ps1').exists()}",
+        f"grok={GrokCLI.find() or ''}",
+        f"state={status.state}",
+        f"kroko_model={_kroko_ready()}",
+        f"sherpa={_importable('sherpa_onnx')}",
+        f"mic={_importable('sounddevice')}",
+    ]
+    Path(tempfile.gettempdir(), "GrokAssistant-check.txt").write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

grok_assistant/_bundle/LICENSE.md

@@ -0,0 +1,39 @@
+# Licencia y límites — Grok Assistant
+
+Versión candidata 1.0. Aplicación experimental.
+
+Autor: Antonio Castellon, Castellon.CH.
+
+## Qué es
+
+Grok Assistant es un programa experimental para hablar con un asistente en este equipo. El audio se queda aquí. Cuando hace falta, el programa envía texto a Grok. Grok y sus herramientas son un servicio de un tercero, no de este programa.
+
+## Responsabilidad
+
+Antonio Castellon no se hace responsable de cualquier fallo de seguridad o brecha que pueda darse por el uso de Grok y de sus herramientas. Eso incluye el acceso a la cuenta, lo que Grok busque o escriba, un archivo que cambie cuando esa opción esté permitida, y cualquier daño o pérdida que venga de ese uso.
+
+El programa se ofrece tal cual, sin garantía. Quien lo ejecuta lo hace por su cuenta.
+
+Si un administrador permite que Grok cambie archivos, esa elección se hace en este equipo. La shell sigue apagada. Aun así, el autor no responde de lo que Grok haga con las herramientas que se hayan dejado activas.
+
+## Texto que manda
+
+Este archivo está en español. La traducción al inglés es una ayuda para leerlo. Si los dos textos no dicen lo mismo, manda el español.
+
+---
+
+# License and limits — Grok Assistant
+
+Release candidate 1.0. Experimental application.
+
+Author: Antonio Castellon, Castellon.CH.
+
+Grok Assistant is an experimental program for talking with an assistant on this computer. The audio stays here. When needed, the program sends text to Grok. Grok and its tools are a third-party service, not part of this program.
+
+Antonio Castellon is not responsible for any security failure or breach that may come from using Grok and its tools. That includes access to the account, what Grok looks up or writes, a file it changes when that option is allowed, and any damage or loss that comes from that use.
+
+The program is offered as it is, without warranty. Anyone who runs it does so on their own account.
+
+If an administrator allows Grok to change files, that choice is made on this computer. The shell stays off. The author is still not answerable for what Grok does with the tools that were left on.
+
+If the Spanish text and this English text differ, the Spanish text prevails.

grok_assistant/_bundle/listeners/dictation.ps1

@@ -0,0 +1,80 @@
+param(
+    [string]$Culture = "es-ES",
+    [string]$PauseFile = "",
+    [string]$ScoreDir = "",
+    [switch]$Probe
+)
+$ErrorActionPreference = "Stop"
+Add-Type -AssemblyName System.Speech
+# The string constructor wants a recognizer id such as MS-3082-80-DESK, not a culture name.
+try {
+    $cultureInfo = [System.Globalization.CultureInfo]::new($Culture)
+    $engine = New-Object System.Speech.Recognition.SpeechRecognitionEngine($cultureInfo)
+} catch {
+    $info = [System.Speech.Recognition.SpeechRecognitionEngine]::InstalledRecognizers() |
+        Where-Object { $_.Culture.Name -eq $Culture } |
+        Select-Object -First 1
+    if (-not $info) {
+        [Console]::Out.WriteLine("ERR:no-recognizer")
+        [Console]::Out.Flush()
+        exit 2
+    }
+    try {
+        $engine = New-Object System.Speech.Recognition.SpeechRecognitionEngine($info)
+    } catch {
+        [Console]::Out.WriteLine("ERR:no-recognizer")
+        [Console]::Out.Flush()
+        exit 2
+    }
+}
+if ($Probe) {
+    [Console]::Out.WriteLine("READY")
+    [Console]::Out.Flush()
+    exit 0
+}
+if ($ScoreDir) {
+    try {
+        $engine.LoadGrammar((New-Object System.Speech.Recognition.DictationGrammar))
+    } catch {
+        [Console]::Out.WriteLine("ERR:no-recognizer")
+        [Console]::Out.Flush()
+        exit 2
+    }
+    Get-ChildItem -LiteralPath $ScoreDir -Filter *.wav | Sort-Object Name | ForEach-Object {
+        $text = ""
+        try {
+            $engine.SetInputToWaveFile($_.FullName)
+            $result = $engine.Recognize()
+            if ($result -and $result.Text) { $text = $result.Text }
+        } catch {
+            $text = ""
+        }
+        [Console]::Out.WriteLine("LINE:" + $_.Name + "|" + $text)
+        [Console]::Out.Flush()
+    }
+    exit 0
+}
+try {
+    $engine.LoadGrammar((New-Object System.Speech.Recognition.DictationGrammar))
+    $engine.SetInputToDefaultAudioDevice()
+} catch {
+    [Console]::Out.WriteLine("ERR:no-microphone")
+    [Console]::Out.Flush()
+    exit 3
+}
+$engine.EndSilenceTimeout = [TimeSpan]::FromMilliseconds(700)
+$engine.EndSilenceTimeoutAmbiguous = [TimeSpan]::FromMilliseconds(700)
+$engine.InitialSilenceTimeout = [TimeSpan]::FromSeconds(2)
+[Console]::Out.WriteLine("READY")
+[Console]::Out.Flush()
+while ($true) {
+    if ($PauseFile -and (Test-Path -LiteralPath $PauseFile)) {
+        Start-Sleep -Milliseconds 200
+        continue
+    }
+    $result = $engine.Recognize()
+    if ($result -and $result.Text) {
+        [Console]::Out.WriteLine("LINE:" + $result.Text)
+        [Console]::Out.Flush()
+    }
+}

grok_assistant/_bundle/listeners/install_speech.ps1

@@ -0,0 +1,19 @@
+param(
+    [Parameter(Mandatory = $true)]
+    [string]$Log
+)
+$ErrorActionPreference = "Stop"
+try {
+    $name = "Language.Speech~~~es-ES~0.0.1.0"
+    $cap = Get-WindowsCapability -Online | Where-Object { $_.Name -eq $name } | Select-Object -First 1
+    if (-not $cap) {
+        throw "Windows no ofrece el idioma de voz es-ES en este equipo."
+    }
+    if ($cap.State -ne "Installed") {
+        Add-WindowsCapability -Online -Name $name | Out-Null
+    }
+    Set-Content -LiteralPath $Log -Value "OK" -Encoding utf8
+} catch {
+    Set-Content -LiteralPath $Log -Value ("ERR:" + $_.Exception.Message) -Encoding utf8
+    exit 1
+}

grok_assistant/_bundle/scripts/build_exe.ps1

@@ -0,0 +1,21 @@
+# Build the single GrokAssistant.exe. This is for making the program, not for installing it.
+$ErrorActionPreference = "Stop"
+$root = Resolve-Path (Join-Path $PSScriptRoot "..")
+Set-Location $root
+$python = $null
+foreach ($candidate in @("python", "py")) {
+    if (Get-Command $candidate -ErrorAction SilentlyContinue) {
+        if ($candidate -eq "py") {
+            $python = & py -3 -c "import sys; print(sys.executable)"
+        } else {
+            $python = & python -c "import sys; print(sys.executable)"
+        }
+        break
+    }
+}
+if (-not $python) { throw "Python 3.11 or newer is required to build the executable." }
+& $python -m pip install --upgrade pip pyinstaller pystray Pillow "sherpa-onnx==1.13.8" "sounddevice==0.5.6" "numpy>=2.2,<2.5"
+& $python -m PyInstaller --noconfirm --clean (Join-Path $root "GrokAssistant.spec")
+$exe = Join-Path $root "dist\GrokAssistant.exe"
+if (-not (Test-Path $exe)) { throw "The executable was not created." }
+Write-Host "Built $exe"

grok_assistant/_bundle/scripts/speak.ps1

@@ -0,0 +1,14 @@
+param(
+    [Parameter(Mandatory = $true)][string]$Path,
+    [int]$Volume = 70,
+    [string]$Voice = ""
+)
+$ErrorActionPreference = "Stop"
+Add-Type -AssemblyName System.Speech
+$synth = New-Object System.Speech.Synthesis.SpeechSynthesizer
+$synth.Volume = [Math]::Max(0, [Math]::Min(100, $Volume))
+if ($Voice) {
+    try { $synth.SelectVoice($Voice) } catch { }
+}
+$text = Get-Content -LiteralPath $Path -Raw -Encoding UTF8
+if ($text) { $synth.Speak($text) }

grok_assistant/_bundle/scripts/voices.ps1

@@ -0,0 +1,6 @@
+$ErrorActionPreference = "Stop"
+Add-Type -AssemblyName System.Speech
+$synth = New-Object System.Speech.Synthesis.SpeechSynthesizer
+$synth.GetInstalledVoices() | ForEach-Object {
+    $_.VoiceInfo.Name + "|" + $_.VoiceInfo.Culture.Name
+}

grok_assistant/build_stamp.txt

@@ -0,0 +1,2 @@
+73c54b29e221
+2026-10-02T07:32:53Z

grok_assistant/buildinfo.py

@@ -0,0 +1,69 @@
+"""The build baked into this copy. About shows it. The updater compares it."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+def _git(cwd: Path, *args: str) -> str:
+    try:
+        from grok_assistant.quiet import no_window
+
+        out = subprocess.check_output(
+            ["git", *args],
+            cwd=cwd,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            stderr=subprocess.DEVNULL,
+            timeout=5,
+            **no_window(),
+        )
+    except (OSError, subprocess.SubprocessError):
+        return ""
+    return out.strip()
+
+
+def _read_file(path: Path) -> tuple[str, str]:
+    try:
+        lines = [line.strip() for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
+    except OSError:
+        return "", ""
+    ident = lines[0] if lines else ""
+    when = lines[1] if len(lines) > 1 else ""
+    if not ident or ident == "unknown":
+        return "", when
+    return ident, when
+
+
+def read_stamp() -> tuple[str, str]:
+    """Return the build id and the UTC time it was made. Empty strings when unknown."""
+    if getattr(sys, "frozen", False):
+        return _read_file(Path(getattr(sys, "_MEIPASS")) / "grok_assistant" / "build_stamp.txt")
+    here = Path(__file__).resolve()
+    checkout = here.parents[2]
+    if (checkout / "scripts" / "speak.ps1").is_file():
+        ident = _git(checkout, "rev-parse", "--short=12", "HEAD")
+        if ident:
+            return ident, _git(checkout, "log", "-1", "--format=%cI")
+    return _read_file(here.parent / "build_stamp.txt")
+
+
+def build_line() -> str:
+    ident, _when = read_stamp()
+    if not ident:
+        return "build —"
+    return f"build {ident}"
+
+
+def write_stamp(path: Path | None = None) -> tuple[str, str]:
+    """Write the source commit and the current UTC time. The executable and the wheel both call this."""
+    dest = Path(path) if path else Path(__file__).resolve().parent / "build_stamp.txt"
+    checkout = Path(__file__).resolve().parents[2]
+    ident = _git(checkout, "rev-parse", "--short=12", "HEAD")
+    when = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    dest.write_text(f"{ident}\n{when}\n", encoding="utf-8")
+    return ident, when

grok_assistant/cloud/__init__.py

@@ -0,0 +1 @@
+"""The door to the Grok executable."""

grok_assistant/cloud/account_agents.py

@@ -0,0 +1,92 @@
+"""Agents the signed-in Grok account already publishes. No prompt is sent."""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+BUNDLE = "https://cli-chat-proxy.grok.com/v1/subagents/bundle"
+SETTINGS = "https://grok.com/rest/user-settings"
+
+
+def agents_from_bundle(payload: dict) -> dict[str, str]:
+    """Name to markdown, from the account bundle. Empty when the shape is not that list."""
+    agents = payload.get("agents") if isinstance(payload, dict) else None
+    if not isinstance(agents, dict):
+        return {}
+    found = {}
+    for name, body in agents.items():
+        title = " ".join(str(name).split())
+        if not title or not isinstance(body, str) or not body.strip():
+            continue
+        found[title] = body if body.endswith("\n") else body + "\n"
+    return found
+
+
+def agents_from_customizations(payload: dict) -> dict[str, str]:
+    """Name to markdown, from grok.com agent customizations. Empty when there are none."""
+    items = payload.get("agentCustomizations") if isinstance(payload, dict) else None
+    if not isinstance(items, list):
+        return {}
+    found = {}
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        raw_name = item.get("name") or item.get("title") or item.get("displayName") or item.get("id")
+        title = " ".join(str(raw_name or "").split())
+        if not title:
+            continue
+        prompt = item.get("instructions") or item.get("systemPrompt") or item.get("prompt") or item.get("description") or ""
+        found[title] = (
+            f"---\nname: {title}\n"
+            "description: Agente de la cuenta de Grok.\n"
+            "prompt_mode: full\nmodel: grok-4.7\n---\n\n"
+            f"{prompt}\n"
+        )
+    return found
+
+
+def fetch_account_agents(auth_path: Path | None = None) -> dict[str, str]:
+    """Agents linked to the signed-in account. {} when the account cannot be read."""
+    creds = _creds(auth_path or Path.home() / ".grok" / "auth.json")
+    if creds is None:
+        return {}
+    key, user_id = creds
+    found = agents_from_bundle(_get(BUNDLE, key, user_id))
+    custom = agents_from_customizations(_get(SETTINGS, key, user_id))
+    found.update(custom)
+    return found
+
+
+def _creds(path: Path) -> tuple[str, str] | None:
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    if not isinstance(raw, dict):
+        return None
+    for item in raw.values():
+        if isinstance(item, dict) and item.get("key"):
+            return str(item["key"]), str(item.get("user_id") or "")
+    return None
+
+
+def _get(url: str, key: str, user_id: str) -> dict:
+    request = urllib.request.Request(
+        url,
+        headers={
+            "Authorization": f"Bearer {key}",
+            "Accept": "application/json",
+            "User-Agent": "GrokAssistant",
+            "X-XAI-Token-Auth": "xai-grok-cli",
+            "x-userid": user_id,
+        },
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=12) as response:
+            payload = json.load(response)
+    except (OSError, urllib.error.URLError, json.JSONDecodeError, TimeoutError):
+        return {}
+    return payload if isinstance(payload, dict) else {}

grok_assistant/cloud/account_usage.py

@@ -0,0 +1,49 @@
+"""How much of the linked Grok account allowance is already used. No audio, no prompt."""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+BILLING = "https://cli-chat-proxy.grok.com/v1/billing?format=credits"
+
+
+def percent_used(payload: dict) -> int | None:
+    """Weekly allowance already spent, 0–100. None when the account did not say."""
+    config = payload.get("config") if isinstance(payload, dict) else None
+    source = config if isinstance(config, dict) else payload
+    if not isinstance(source, dict) or source.get("creditUsagePercent") is None:
+        return None
+    try:
+        value = int(round(float(source["creditUsagePercent"])))
+    except (TypeError, ValueError):
+        return None
+    return max(0, min(100, value))
+
+
+def fetch_account_percent(auth_path: Path | None = None) -> int | None:
+    path = auth_path or Path.home() / ".grok" / "auth.json"
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    key = ""
+    if isinstance(raw, dict):
+        for item in raw.values():
+            if isinstance(item, dict) and item.get("key"):
+                key = str(item["key"])
+                break
+    if not key:
+        return None
+    request = urllib.request.Request(
+        BILLING,
+        headers={"Authorization": f"Bearer {key}", "Accept": "application/json", "User-Agent": "GrokAssistant"},
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=15) as response:
+            payload = json.load(response)
+    except (OSError, urllib.error.URLError, json.JSONDecodeError, TimeoutError):
+        return None
+    return percent_used(payload)