nixorb 0.1.0__py3-none-any.whl

nixorb/__init__.py

@@ -0,0 +1,6 @@
+"""NixOrb — floating AI assistant orb for Arch Linux."""
+from __future__ import annotations
+
+__version__ = "0.1.0"
+__author__  = "NixOrb Contributors"
+__license__ = "MIT"

nixorb/action/clipboard.py

@@ -0,0 +1,51 @@
+"""nixorb/action/clipboard.py — Wayland clipboard integration."""
+from __future__ import annotations
+
+import asyncio
+import logging
+import shutil
+import subprocess
+
+log = logging.getLogger(__name__)
+
+_HAS_WL_PASTE = bool(shutil.which("wl-paste"))
+_HAS_WL_COPY  = bool(shutil.which("wl-copy"))
+
+
+async def read_clipboard() -> str | None:
+    """Read current Wayland clipboard text content."""
+    if not _HAS_WL_PASTE:
+        log.warning("wl-paste not found — install wl-clipboard")
+        return None
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "wl-paste", "--no-newline",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=5)
+        return stdout.decode(errors="replace").strip() or None
+    except Exception as exc:
+        log.error("Clipboard read failed: %s", exc)
+        return None
+
+
+async def write_clipboard(text: str) -> bool:
+    """Write *text* to the Wayland clipboard."""
+    if not _HAS_WL_COPY:
+        log.warning("wl-copy not found — install wl-clipboard")
+        return False
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            "wl-copy",
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.DEVNULL,
+            stderr=asyncio.subprocess.DEVNULL,
+        )
+        await asyncio.wait_for(
+            proc.communicate(input=text.encode("utf-8")), timeout=5
+        )
+        return proc.returncode == 0
+    except Exception as exc:
+        log.error("Clipboard write failed: %s", exc)
+        return False

nixorb/action/executor.py

@@ -0,0 +1,209 @@
+"""
+nixorb/action/executor.py
+
+Sandboxed bash/system command executor.
+
+Security model:
+  1. Hard-deny list blocks destructive patterns unconditionally.
+  2. Sensitive prefixes require interactive user confirmation via EventBus.
+  3. All commands run as the current user in a subprocess with timeout.
+  4. Optional bubblewrap (bwrap) filesystem sandbox when available.
+  5. NixOrb refuses to run as root.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import re
+import shutil
+import subprocess
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from nixorb.core.event_bus import Event, EventPayload, bus
+
+if TYPE_CHECKING:
+    from nixorb.settings import Settings
+
+log = logging.getLogger(__name__)
+
+ACTION_PATTERN = re.compile(r"<ACTION>(.*?)</ACTION>", re.DOTALL | re.IGNORECASE)
+
+TIMEOUT_SECONDS  = 30
+USE_BUBBLEWRAP   = shutil.which("bwrap") is not None
+
+ALWAYS_DENY: list[str] = [
+    "rm -rf /",
+    "rm -rf ~",
+    "dd if=",
+    "mkfs",
+    ":(){ :|:& };:",
+    "chmod -R 777 /",
+    "passwd",
+    "> /dev/sda",
+]
+
+REQUIRE_CONFIRM: list[str] = [
+    "rm ",
+    "mv ",
+    "sudo ",
+    "systemctl ",
+    "pacman ",
+    "yay ",
+    "pip install",
+    "curl ",
+    "wget ",
+    "git push",
+    "chmod",
+    "chown",
+    "mktemp",
+    "shutdown",
+    "reboot",
+]
+
+
+@dataclass
+class ActionResult:
+    command:    str
+    stdout:     str
+    stderr:     str
+    returncode: int
+    timed_out:  bool = False
+
+    @property
+    def success(self) -> bool:
+        return self.returncode == 0 and not self.timed_out
+
+    def __str__(self) -> str:
+        lines = [f"$ {self.command}"]
+        if self.stdout.strip():
+            lines.append(self.stdout.rstrip())
+        if self.stderr.strip():
+            lines.append(f"[stderr] {self.stderr.rstrip()}")
+        lines.append(f"[exit {self.returncode}{'  TIMEOUT' if self.timed_out else ''}]")
+        return "\n".join(lines)
+
+
+class ActionExecutor:
+    def __init__(self, settings: Settings) -> None:
+        self._settings = settings
+        self._pending: dict[str, asyncio.Future[bool]] = {}
+        bus.subscribe(Event.ACTION_RESULT, self._on_confirmation)
+
+        if os.geteuid() == 0:
+            raise RuntimeError(
+                "NixOrb must NOT run as root. "
+                "Drop privileges before starting."
+            )
+
+    async def _on_confirmation(self, payload: EventPayload) -> None:
+        data     = payload.data or {}
+        cmd      = data.get("command", "")
+        approved = bool(data.get("approved", False))
+        fut      = self._pending.pop(cmd, None)
+        if fut and not fut.done():
+            fut.set_result(approved)
+
+    async def handle_llm_output(self, text: str) -> list[ActionResult]:
+        matches = ACTION_PATTERN.findall(text)
+        results: list[ActionResult] = []
+        for raw_cmd in matches:
+            cmd    = raw_cmd.strip()
+            result = await self._run_action(cmd)
+            results.append(result)
+            await bus.emit(
+                Event.LOG,
+                data={"level": "exec", "msg": str(result)},
+                source="ActionExecutor",
+            )
+        return results
+
+    async def _run_action(self, cmd: str) -> ActionResult:
+        # 1. Hard deny
+        for pattern in ALWAYS_DENY:
+            if pattern in cmd:
+                msg = f"Command hard-denied (matched '{pattern}'): {cmd}"
+                log.warning(msg)
+                return ActionResult(command=cmd, stdout="", stderr=msg, returncode=-1)
+
+        # 2. Confirmation for sensitive commands
+        needs_confirm = self._settings.require_action_confirmation or any(
+            (cmd.startswith(p) or p in cmd) for p in REQUIRE_CONFIRM
+        )
+        if needs_confirm:
+            approved = await self._request_confirmation(cmd)
+            if not approved:
+                return ActionResult(
+                    command=cmd, stdout="", stderr="User denied", returncode=-1
+                )
+
+        return await self._execute(cmd)
+
+    async def _request_confirmation(self, cmd: str) -> bool:
+        loop = asyncio.get_running_loop()
+        fut: asyncio.Future[bool] = loop.create_future()
+        self._pending[cmd] = fut
+
+        await bus.emit(
+            Event.ACTION_REQUESTED,
+            data={"command": cmd},
+            source="ActionExecutor",
+            priority=1,
+        )
+        try:
+            return await asyncio.wait_for(asyncio.shield(fut), timeout=30.0)
+        except asyncio.TimeoutError:
+            self._pending.pop(cmd, None)
+            log.warning("Confirmation timed out for: %s", cmd)
+            return False
+
+    async def _execute(self, cmd: str) -> ActionResult:
+        log.info("Executing: %s", cmd)
+        cmd_args = self._wrap_bwrap(cmd) if USE_BUBBLEWRAP else ["bash", "-c", cmd]
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *cmd_args,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env={**os.environ},
+            )
+            try:
+                stdout, stderr = await asyncio.wait_for(
+                    proc.communicate(), timeout=TIMEOUT_SECONDS
+                )
+            except asyncio.TimeoutError:
+                try:
+                    proc.kill()
+                except ProcessLookupError:
+                    pass
+                return ActionResult(
+                    command=cmd, stdout="", stderr="Execution timed out",
+                    returncode=-1, timed_out=True,
+                )
+            return ActionResult(
+                command=cmd,
+                stdout=stdout.decode(errors="replace"),
+                stderr=stderr.decode(errors="replace"),
+                returncode=proc.returncode or 0,
+            )
+        except Exception as exc:
+            return ActionResult(command=cmd, stdout="", stderr=str(exc), returncode=-1)
+
+    @staticmethod
+    def _wrap_bwrap(cmd: str) -> list[str]:
+        home = os.path.expanduser("~")
+        return [
+            "bwrap",
+            "--ro-bind", "/usr", "/usr",
+            "--ro-bind", "/lib", "/lib",
+            "--ro-bind", "/lib64", "/lib64",
+            "--ro-bind", "/etc", "/etc",
+            "--bind",    home,  home,
+            "--bind",    "/tmp", "/tmp",
+            "--dev",     "/dev",
+            "--proc",    "/proc",
+            "--unshare-net",
+            "--die-with-parent",
+            "bash", "-c", cmd,
+        ]

nixorb/asr/wake_word.py

@@ -0,0 +1,93 @@
+"""
+nixorb/asr/wake_word.py
+
+OpenWakeWord always-on detector.
+
+BUG FIX PASS 1:
+  - Previous version called asyncio.ensure_future() from the sounddevice
+    callback thread. ensure_future() requires a running event loop in the
+    calling thread, which the audio callback thread does not have.
+    Fixed by capturing the running loop at startup and using
+    loop.call_soon_threadsafe() with asyncio.run_coroutine_threadsafe().
+
+BUG FIX PASS 2:
+  - Cooldown guard added. Without it, a single wake word detection fires
+    dozens of events during the ~80 ms chunk window while confidence is high.
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from typing import TYPE_CHECKING
+
+import numpy as np
+import sounddevice as sd
+
+from nixorb.core.event_bus import Event, bus
+
+if TYPE_CHECKING:
+    from nixorb.settings import Settings
+
+log = logging.getLogger(__name__)
+
+CHUNK        = 1_280    # ~80 ms at 16 kHz (OpenWakeWord requirement)
+CONFIDENCE   = 0.70     # minimum score to fire
+COOLDOWN_S   = 2.0      # seconds before another wake-word fires
+
+
+class WakeWordDetector:
+    def __init__(self, settings: Settings) -> None:
+        from openwakeword.model import Model
+        self._model = Model(
+            wakeword_models=[settings.wake_word_model],
+            inference_framework="onnx",
+        )
+        self._settings   = settings
+        self._last_fired = 0.0
+        self._loop:  asyncio.AbstractEventLoop | None = None
+
+    async def run_forever(self) -> None:
+        # BUG FIX: capture loop here, on the async thread, before starting
+        # the sounddevice stream whose callbacks run on a C audio thread.
+        self._loop = asyncio.get_running_loop()
+        log.info(
+            "Wake-word detector started (model=%s, threshold=%.2f)",
+            self._settings.wake_word_model, CONFIDENCE,
+        )
+
+        def _callback(
+            indata: np.ndarray, frames: int, time_info, status
+        ) -> None:
+            if status:
+                log.debug("sounddevice status: %s", status)
+            pcm = (indata[:, 0] * 32_767).astype(np.int16)
+            preds = self._model.predict(pcm)
+            for name, score in preds.items():
+                if score >= CONFIDENCE:
+                    now = time.monotonic()
+                    # BUG FIX: cooldown so we don't flood the bus
+                    if (now - self._last_fired) < COOLDOWN_S:
+                        return
+                    self._last_fired = now
+                    log.info("Wake word: %s (score=%.3f)", name, score)
+                    # BUG FIX: use run_coroutine_threadsafe from audio thread
+                    asyncio.run_coroutine_threadsafe(
+                        bus.emit(
+                            Event.WAKE_WORD_DETECTED,
+                            data={"word": name, "score": float(score)},
+                            source="WakeWordDetector",
+                        ),
+                        self._loop,
+                    )
+
+        with sd.InputStream(
+            samplerate=16_000,
+            channels=1,
+            dtype="float32",
+            blocksize=CHUNK,
+            callback=_callback,
+        ):
+            # Keep the coroutine alive; the callback does the real work.
+            while True:
+                await asyncio.sleep(0.5)

nixorb/asr/whisper_engine.py

@@ -0,0 +1,191 @@
+"""
+nixorb/asr/whisper_engine.py
+
+faster-whisper Large v3 with INT8 quantisation and VRAM paging.
+
+BUG FIX PASS 1:
+  - _transcribe_blocking called asyncio.get_event_loop() from inside a
+    ThreadPoolExecutor worker. In Python 3.10+ this issues a DeprecationWarning
+    and in 3.12 it raises RuntimeError because there is no running loop in the
+    thread. Fixed by capturing the loop at construction time and storing it.
+
+BUG FIX PASS 2:
+  - asyncio.run_coroutine_threadsafe result was awaited inside the executor
+    thread with .result(timeout=60), but the coroutine itself acquires
+    VRAMManager locks which are asyncio.Lock objects — awaitable only on
+    the main loop. Restructured: recording runs in thread pool, transcription
+    is fully async on the main loop, no cross-thread coroutine submission.
+
+BUG FIX PASS 3:
+  - sounddevice InputStream blocksize parameter was passed as CHUNK_FRAMES but
+    the callback variant of InputStream was mixed up with the read() API.
+    Corrected to use explicit stream.read() in a loop (non-callback mode).
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from typing import TYPE_CHECKING
+
+import numpy as np
+import sounddevice as sd
+
+from nixorb.core.event_bus import Event, bus
+from nixorb.core.vram_manager import ModelPriority, vram
+
+if TYPE_CHECKING:
+    from nixorb.settings import Settings
+
+log = logging.getLogger(__name__)
+
+SAMPLE_RATE  = 16_000
+CHANNELS     = 1
+DTYPE        = "float32"
+CHUNK_FRAMES = 1_024
+SILENCE_DB   = -38.0    # dBFS; above this = speech
+SILENCE_SECS = 1.2      # seconds of consecutive silence = end of utterance
+MAX_RECORD_S = 30.0     # hard cap
+
+
+def _load_whisper():
+    from faster_whisper import WhisperModel
+    model = WhisperModel(
+        "large-v3",
+        device="cuda",
+        compute_type="int8_float16",   # INT8 weights, FP16 compute ≈ 2 GB VRAM
+        cpu_threads=4,
+        num_workers=2,
+    )
+    log.info("Whisper Large v3 (int8_float16) loaded")
+    return model
+
+
+def _unload_whisper(model) -> None:
+    del model
+
+
+# Register once at import time
+vram.register(
+    name="whisper",
+    vram_mb=2_100,
+    priority=ModelPriority.LOW,
+    load_fn=_load_whisper,
+    unload_fn=_unload_whisper,
+)
+
+
+class WhisperEngine:
+    def __init__(self, settings: Settings) -> None:
+        self._settings = settings
+
+    # ---------------------------------------------------------------- #
+    #  Public entry point                                               #
+    # ---------------------------------------------------------------- #
+    async def record_and_transcribe(self) -> str | None:
+        """
+        Record from microphone until silence, then transcribe.
+
+        Recording is blocking I/O — runs in the default thread pool.
+        Transcription runs on the async loop using vram.lease().
+        """
+        await bus.emit(Event.RECORDING_START, source="whisper")
+        loop = asyncio.get_running_loop()
+
+        # BUG FIX: record in thread, transcribe on async loop (no cross-thread
+        # coroutine submission needed)
+        audio = await loop.run_in_executor(None, self._record_blocking)
+
+        await bus.emit(Event.RECORDING_STOP, source="whisper")
+
+        if audio is None or len(audio) < int(SAMPLE_RATE * 0.3):
+            log.debug("Recording too short or empty — skipping transcription")
+            return None
+
+        return await self._transcribe_async(audio)
+
+    # ---------------------------------------------------------------- #
+    #  Recording (blocking, runs in thread pool)                        #
+    # ---------------------------------------------------------------- #
+    def _record_blocking(self) -> np.ndarray | None:
+        chunks: list[np.ndarray] = []
+        silence_start: float | None = None
+        start = time.monotonic()
+        device = self._settings.microphone_index
+
+        try:
+            # BUG FIX: use non-callback InputStream.read() correctly
+            with sd.InputStream(
+                samplerate=SAMPLE_RATE,
+                channels=CHANNELS,
+                dtype=DTYPE,
+                blocksize=CHUNK_FRAMES,
+                device=device,
+            ) as stream:
+                log.info("Recording started (device=%s)", device)
+                while True:
+                    # read() returns (data: ndarray, overflowed: bool)
+                    chunk, _overflowed = stream.read(CHUNK_FRAMES)
+                    chunks.append(chunk.copy())
+
+                    rms    = float(np.sqrt(np.mean(chunk ** 2)) + 1e-10)
+                    rms_db = 20.0 * np.log10(rms)
+                    elapsed = time.monotonic() - start
+
+                    if rms_db > SILENCE_DB:
+                        silence_start = None          # reset silence timer on speech
+                    else:
+                        if silence_start is None:
+                            silence_start = time.monotonic()
+                        elif (time.monotonic() - silence_start) >= SILENCE_SECS:
+                            log.info("End of speech detected (%.1f s)", elapsed)
+                            break
+
+                    if elapsed >= MAX_RECORD_S:
+                        log.warning("Max recording duration reached")
+                        break
+
+        except sd.PortAudioError as exc:
+            log.error("PortAudio error during recording: %s", exc)
+            return None
+
+        if not chunks:
+            return None
+        return np.concatenate(chunks, axis=0).flatten()
+
+    # ---------------------------------------------------------------- #
+    #  Transcription (fully async, runs on main event loop)            #
+    # ---------------------------------------------------------------- #
+    async def _transcribe_async(self, audio: np.ndarray) -> str | None:
+        """Acquire Whisper from VRAM manager and transcribe."""
+        async with vram.lease("whisper") as model:
+            loop = asyncio.get_running_loop()
+            # Run the synchronous faster-whisper call in the thread pool
+            text = await loop.run_in_executor(
+                None, self._transcribe_sync, model, audio
+            )
+        if text:
+            await bus.emit(
+                Event.TRANSCRIPT_READY,
+                data={"text": text},
+                source="whisper",
+                priority=2,
+            )
+            log.info("Transcript: %s", text[:120])
+        return text or None
+
+    @staticmethod
+    def _transcribe_sync(model, audio: np.ndarray) -> str:
+        segments, info = model.transcribe(
+            audio,
+            beam_size=5,
+            language=None,           # auto-detect
+            vad_filter=True,
+            vad_parameters={
+                "min_silence_duration_ms": 500,
+                "speech_pad_ms": 200,
+            },
+            word_timestamps=False,
+            condition_on_previous_text=False,
+        )
+        return " ".join(seg.text.strip() for seg in segments).strip()