alinux 0.1.0__tar.gz

alinux-0.1.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.5
+Name: alinux
+Version: 0.1.0
+Summary: Alinux AI orchestration shell for minimal Linux desktops
+Author: Alinux contributors
+License: MIT
+Keywords: ai,automation,desktop,fluxbox,linux
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Desktop Environment
+Requires-Python: >=3.10
+Requires-Dist: openai<2,>=1.40.0
+Requires-Dist: pydantic<3,>=2.7.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.6.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Alinux
+
+Alinux is an AI orchestration shell for a minimal Debian 12 desktop running
+Fluxbox. It converts natural-language requests into a small, validated set of
+desktop actions.
+
+## Install
+
+```bash
+python3 -m venv .venv
+. .venv/bin/activate
+python -m pip install .
+```
+
+For model access, export a key and optionally choose a provider/model. Any
+OpenAI-compatible API can be configured with a custom endpoint:
+
+```bash
+export ALINUX_API_KEY='your-key'
+export ALINUX_MODEL='gpt-4o-mini'
+export ALINUX_API_BASE_URL='https://your-provider.example/v1'
+```
+
+Groq is supported directly, including Alinux's built-in open model preset:
+
+```bash
+export ALINUX_PROVIDER='groq'
+export ALINUX_API_KEY='your-groq-key'
+alinux
+```
+
+With `ALINUX_PROVIDER=groq` and no model override, Alinux uses
+`llama-3.3-70b-versatile` at Groq's OpenAI-compatible endpoint. You can also
+select it explicitly with `ALINUX_MODEL=llama-3.3-70b-versatile`.
+
+The desktop hooks expect `xdotool`, `amixer`, `free`, and `uptime`. Missing
+tools are reported as readable responses rather than terminating Alinux.
+
+## Run
+
+```bash
+alinux
+```
+
+Open the graphical Alinux window from a terminal with:
+
+```bash
+alinux open
+```
+
+To add **Open Alinux** to the Fluxbox desktop context menu, run this once
+inside the Fluxbox session:
+
+```bash
+alinux install-fluxbox-menu
+```
+
+Then restart or reconfigure Fluxbox. The installer updates
+`~/.fluxbox/menu` without replacing your existing entries. The GUI requires
+Debian's `python3-tk` package and a valid `DISPLAY`.
+
+Type requests such as `show system status`, `turn the volume down`, or
+`open the terminal`. Enter `quit` or press `Ctrl-D` to exit.
+
+Alinux never executes arbitrary shell text from the model. Only the operations
+listed in its system prompt and `system_controls.py` are routable.

alinux-0.1.0/README.md

@@ -0,0 +1,66 @@
+# Alinux
+
+Alinux is an AI orchestration shell for a minimal Debian 12 desktop running
+Fluxbox. It converts natural-language requests into a small, validated set of
+desktop actions.
+
+## Install
+
+```bash
+python3 -m venv .venv
+. .venv/bin/activate
+python -m pip install .
+```
+
+For model access, export a key and optionally choose a provider/model. Any
+OpenAI-compatible API can be configured with a custom endpoint:
+
+```bash
+export ALINUX_API_KEY='your-key'
+export ALINUX_MODEL='gpt-4o-mini'
+export ALINUX_API_BASE_URL='https://your-provider.example/v1'
+```
+
+Groq is supported directly, including Alinux's built-in open model preset:
+
+```bash
+export ALINUX_PROVIDER='groq'
+export ALINUX_API_KEY='your-groq-key'
+alinux
+```
+
+With `ALINUX_PROVIDER=groq` and no model override, Alinux uses
+`llama-3.3-70b-versatile` at Groq's OpenAI-compatible endpoint. You can also
+select it explicitly with `ALINUX_MODEL=llama-3.3-70b-versatile`.
+
+The desktop hooks expect `xdotool`, `amixer`, `free`, and `uptime`. Missing
+tools are reported as readable responses rather than terminating Alinux.
+
+## Run
+
+```bash
+alinux
+```
+
+Open the graphical Alinux window from a terminal with:
+
+```bash
+alinux open
+```
+
+To add **Open Alinux** to the Fluxbox desktop context menu, run this once
+inside the Fluxbox session:
+
+```bash
+alinux install-fluxbox-menu
+```
+
+Then restart or reconfigure Fluxbox. The installer updates
+`~/.fluxbox/menu` without replacing your existing entries. The GUI requires
+Debian's `python3-tk` package and a valid `DISPLAY`.
+
+Type requests such as `show system status`, `turn the volume down`, or
+`open the terminal`. Enter `quit` or press `Ctrl-D` to exit.
+
+Alinux never executes arbitrary shell text from the model. Only the operations
+listed in its system prompt and `system_controls.py` are routable.

alinux-0.1.0/alinux/__init__.py

@@ -0,0 +1,3 @@
+"""Alinux AI orchestration shell for minimal Linux desktops."""
+
+__version__ = "0.1.0"

alinux-0.1.0/alinux/__main__.py

@@ -0,0 +1,6 @@
+"""Allow Alinux to run with ``python -m alinux``."""
+
+from .main import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

alinux-0.1.0/alinux/agent.py

@@ -0,0 +1,98 @@
+"""LLM-backed intent parsing for the Alinux shell."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field, ValidationError
+
+BUILT_IN_MODELS = {
+    "llama-3.3-70b-versatile": {
+        "provider": "groq",
+        "base_url": "https://api.groq.com/openai/v1",
+    },
+}
+
+
+class AgentAction(BaseModel):
+    """The only action contract accepted by the desktop loop."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    action: Literal["system_command", "launch_app", "respond_to_user"]
+    parameter: str = Field(max_length=500)
+    thought: str = Field(default="", max_length=1000)
+
+
+SYSTEM_PROMPT = """You are the core brain of Alinux, a minimal Debian 12 Linux desktop using Fluxbox.
+Translate the user's request into exactly one safe structured action.
+You may use system_command for status, windows, volume up, volume down, or volume mute.
+Use launch_app only with terminal, browser, or file manager.
+Use respond_to_user for questions, unsupported requests, or requests requiring explanation.
+Never invent shell commands, never request arbitrary command execution, and never claim an action succeeded.
+Return only valid JSON matching this schema:
+{"action":"system_command|launch_app|respond_to_user","parameter":"...","thought":"..."}
+"""
+
+
+class Agent:
+    """Convert natural language into validated actions using an OpenAI-compatible API."""
+
+    def __init__(
+        self,
+        model: str | None = None,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        provider: str | None = None,
+    ) -> None:
+        configured_model = model or os.getenv("ALINUX_MODEL")
+        self.model = configured_model or "gpt-4o-mini"
+        model_config = BUILT_IN_MODELS.get(self.model, {})
+        self.provider = (provider or os.getenv("ALINUX_PROVIDER") or model_config.get("provider", "openai")).lower()
+        self.base_url = base_url or os.getenv("ALINUX_API_BASE_URL") or model_config.get("base_url")
+        self.api_key = api_key or os.getenv("ALINUX_API_KEY") or os.getenv("OPENAI_API_KEY")
+        if self.provider == "groq" and configured_model is None and model is None:
+            self.model = "llama-3.3-70b-versatile"
+            self.base_url = self.base_url or "https://api.groq.com/openai/v1"
+        self._client = None
+        if self.api_key:
+            try:
+                from openai import OpenAI
+
+                client_options = {"api_key": self.api_key}
+                if self.base_url:
+                    client_options["base_url"] = self.base_url
+                self._client = OpenAI(**client_options)
+            except ImportError:
+                self._client = None
+
+    def decide(self, user_text: str) -> AgentAction:
+        """Return a validated action, falling back safely when the LLM is unavailable."""
+        if not user_text.strip():
+            return AgentAction(action="respond_to_user", parameter="Please enter a request.")
+        if self._client is None:
+            return AgentAction(
+                action="respond_to_user",
+                parameter="Alinux needs ALINUX_API_KEY (or OPENAI_API_KEY) and the openai package to interpret requests.",
+            )
+        try:
+            response = self._client.chat.completions.create(
+                model=self.model,
+                temperature=0,
+                response_format={"type": "json_object"},
+                messages=[
+                    {"role": "system", "content": SYSTEM_PROMPT},
+                    {"role": "user", "content": user_text.strip()},
+                ],
+            )
+            content = response.choices[0].message.content or ""
+            return AgentAction.model_validate(json.loads(content))
+        except (json.JSONDecodeError, ValidationError, IndexError, TypeError, ValueError) as exc:
+            return AgentAction(
+                action="respond_to_user",
+                parameter=f"Alinux could not understand the model response safely: {exc}.",
+            )
+        except Exception as exc:  # noqa: BLE001 - model failures must not stop the shell
+            return AgentAction(action="respond_to_user", parameter=f"Alinux model error: {exc}")

alinux-0.1.0/alinux/fluxbox.py

@@ -0,0 +1,34 @@
+"""Fluxbox menu integration for Alinux."""
+
+from __future__ import annotations
+
+import os
+import tempfile
+from pathlib import Path
+
+_MENU_ENTRY = "[exec] (Open Alinux) {alinux open}"
+
+
+def install_fluxbox_menu(menu_path: str | os.PathLike[str] | None = None) -> str:
+    """Add an Open Alinux entry to the user's Fluxbox menu idempotently."""
+    path = Path(menu_path).expanduser() if menu_path else Path.home() / ".fluxbox" / "menu"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    existing = path.read_text(encoding="utf-8") if path.exists() else "[begin] (Fluxbox)\n[end]\n"
+    if _MENU_ENTRY in existing:
+        return f"Alinux is already in the Fluxbox menu at {path}."
+    lines = existing.splitlines()
+    end_index = next((index for index, line in enumerate(lines) if line.strip() == "[end]"), len(lines))
+    lines.insert(end_index, _MENU_ENTRY)
+    content = "\n".join(lines).rstrip() + "\n"
+    fd, temporary_path = tempfile.mkstemp(prefix=".alinux-menu-", dir=path.parent, text=True)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as temporary_file:
+            temporary_file.write(content)
+        os.replace(temporary_path, path)
+    except Exception:
+        try:
+            os.unlink(temporary_path)
+        except OSError:
+            pass
+        raise
+    return f"Added Open Alinux to the Fluxbox menu at {path}. Restart or reconfigure Fluxbox to see it."

alinux-0.1.0/alinux/gui.py

@@ -0,0 +1,70 @@
+"""Tkinter desktop interface for Alinux."""
+
+from __future__ import annotations
+
+import tkinter as tk
+from tkinter import ttk
+
+from .agent import Agent
+from .main import _dispatch
+
+
+class AlinuxWindow:
+    """Small desktop chat window that routes requests through the Agent."""
+
+    def __init__(self, root: tk.Tk, agent: Agent | None = None) -> None:
+        self.root = root
+        self.agent = agent or Agent()
+        self.root.title("Alinux")
+        self.root.geometry("640x460")
+        self.root.minsize(480, 320)
+
+        frame = ttk.Frame(root, padding=16)
+        frame.pack(fill=tk.BOTH, expand=True)
+        ttk.Label(frame, text="Alinux", font=("TkDefaultFont", 18, "bold")).pack(anchor=tk.W)
+        ttk.Label(frame, text="Linux desktop control through natural language").pack(anchor=tk.W, pady=(0, 12))
+
+        self.output = tk.Text(frame, height=16, state=tk.DISABLED, wrap=tk.WORD)
+        self.output.pack(fill=tk.BOTH, expand=True)
+        self.output.tag_configure("user", foreground="#245b9e")
+        self.output.tag_configure("assistant", foreground="#1f6b45")
+
+        controls = ttk.Frame(frame)
+        controls.pack(fill=tk.X, pady=(12, 0))
+        self.input = ttk.Entry(controls)
+        self.input.pack(side=tk.LEFT, fill=tk.X, expand=True)
+        self.input.bind("<Return>", lambda _event: self.submit())
+        ttk.Button(controls, text="Send", command=self.submit).pack(side=tk.LEFT, padx=(8, 0))
+        self.input.focus_set()
+        self._write("Alinux is ready. Ask for system status, volume changes, or an app to open.\n", "assistant")
+
+    def _write(self, text: str, tag: str) -> None:
+        self.output.configure(state=tk.NORMAL)
+        self.output.insert(tk.END, text, tag)
+        self.output.see(tk.END)
+        self.output.configure(state=tk.DISABLED)
+
+    def submit(self) -> None:
+        request = self.input.get().strip()
+        if not request:
+            return
+        self.input.delete(0, tk.END)
+        self._write(f"You: {request}\n", "user")
+        try:
+            response = _dispatch(self.agent.decide(request))
+        except Exception as exc:  # noqa: BLE001 - GUI must remain open after a request failure
+            response = f"Alinux recovered from an error: {exc}"
+        self._write(f"Alinux: {response}\n\n", "assistant")
+
+
+def open_gui(agent: Agent | None = None) -> int:
+    """Open the Alinux desktop window and return a process exit status."""
+    try:
+        root = tk.Tk()
+    except (ImportError, tk.TclError) as exc:
+        print(f"Could not open the Alinux GUI: {exc}")
+        print("Install python3-tk and ensure DISPLAY points to the Fluxbox session.")
+        return 1
+    AlinuxWindow(root, agent)
+    root.mainloop()
+    return 0

alinux-0.1.0/alinux/main.py

@@ -0,0 +1,66 @@
+"""Command-line entry point for Alinux."""
+
+from __future__ import annotations
+
+import argparse
+
+from . import system_controls
+from .agent import Agent
+
+
+def _dispatch(agent_action) -> str:
+    if agent_action.action == "launch_app":
+        return system_controls.launch_app(agent_action.parameter)
+    if agent_action.action == "system_command":
+        return system_controls.execute_system_command(agent_action.parameter)
+    return agent_action.parameter
+
+
+def _interactive() -> None:
+    """Run the resilient interactive terminal loop."""
+    print("Alinux ready. Type a request, or 'quit' to exit.")
+    agent = Agent()
+    while True:
+        try:
+            user_text = input("alinux> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\nAlinux stopped.")
+            return
+        if user_text.lower() in {"quit", "exit"}:
+            print("Alinux stopped.")
+            return
+        try:
+            print(_dispatch(agent.decide(user_text)))
+        except Exception as exc:  # noqa: BLE001 - the interactive loop must recover
+            print(f"Alinux recovered from an error: {exc}")
+
+
+def main() -> int:
+    """Run the GUI, Fluxbox installer, or terminal interface."""
+    parser = argparse.ArgumentParser(prog="alinux", description="Alinux Linux desktop assistant")
+    parser.add_argument(
+        "command",
+        nargs="?",
+        choices=("open", "install-fluxbox-menu"),
+        help="open the GUI or install its Fluxbox context-menu entry",
+    )
+    args = parser.parse_args()
+    if args.command == "open":
+        try:
+            from .gui import open_gui
+        except ImportError:
+            print("Could not open the Alinux GUI: install Debian's python3-tk package.")
+            return 1
+
+        return open_gui()
+    if args.command == "install-fluxbox-menu":
+        from .fluxbox import install_fluxbox_menu
+
+        print(install_fluxbox_menu())
+        return 0
+    _interactive()
+    return 0
+
+
+if __name__ == "__main__":
+    main()

alinux-0.1.0/alinux/system_controls.py

@@ -0,0 +1,156 @@
+"""Small, predictable Linux desktop control functions for Alinux.
+
+All subprocess calls use argument lists and timeouts. Operations intentionally
+cover a narrow set of desktop actions so an LLM cannot directly execute an
+arbitrary shell command.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+from collections.abc import Sequence
+
+_DEFAULT_TIMEOUT = 8
+_ALLOWED_APPS = {
+    "terminal": ("x-terminal-emulator",),
+    "browser": ("xdg-open", "https://www.google.com"),
+    "file manager": ("xdg-open", os.path.expanduser("~")),
+}
+
+
+def _run(command: Sequence[str], timeout: int = _DEFAULT_TIMEOUT) -> subprocess.CompletedProcess[str]:
+    """Run a desktop command without invoking a shell."""
+    return subprocess.run(
+        list(command),
+        check=False,
+        capture_output=True,
+        text=True,
+        timeout=timeout,
+    )
+
+
+def _tool_available(tool: str) -> bool:
+    return shutil.which(tool) is not None
+
+
+def launch_app(application: str) -> str:
+    """Launch a known desktop application by friendly name."""
+    name = application.strip().lower()
+    command = _ALLOWED_APPS.get(name)
+    if command is None:
+        return f"I cannot launch {application!r}; supported apps are terminal, browser, and file manager."
+    if not _tool_available(command[0]):
+        return f"Cannot launch {name}: required command {command[0]!r} is not installed."
+    try:
+        subprocess.Popen(list(command), stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    except OSError as exc:
+        return f"Could not launch {name}: {exc}"
+    return f"Launched {name}."
+
+
+def adjust_volume(change: str) -> str:
+    """Adjust ALSA master volume using amixer."""
+    if not _tool_available("amixer"):
+        return "Cannot adjust volume: amixer is not installed."
+    normalized = change.strip().lower()
+    if normalized in {"up", "increase", "louder", "+"}:
+        value = "5%+"
+        description = "increased"
+    elif normalized in {"down", "decrease", "quieter", "-"}:
+        value = "5%-"
+        description = "decreased"
+    elif normalized in {"mute", "muted"}:
+        value = "toggle"
+        description = "toggled"
+    else:
+        return "Volume parameter must be up, down, or mute."
+    try:
+        result = _run(("amixer", "-q", "sset", "Master", value))
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return f"Volume adjustment failed: {exc}"
+    if result.returncode != 0:
+        detail = result.stderr.strip() or "amixer returned an error"
+        return f"Volume adjustment failed: {detail}"
+    return f"Volume {description}."
+
+
+def list_windows() -> str:
+    """Return active window IDs and titles from xdotool."""
+    if not _tool_available("xdotool"):
+        return "Cannot list windows: xdotool is not installed."
+    try:
+        result = _run(("xdotool", "search", "--name", "."))
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return f"Window listing failed: {exc}"
+    if result.returncode != 0 or not result.stdout.strip():
+        return "No active windows found."
+    windows: list[str] = []
+    for window_id in result.stdout.splitlines():
+        window_id = window_id.strip()
+        if not window_id:
+            continue
+        title_result = _run(("xdotool", "getwindowname", window_id))
+        title = title_result.stdout.strip() if title_result.returncode == 0 else "(untitled)"
+        windows.append(f"{window_id}: {title}")
+    return "Active windows:\n" + "\n".join(windows) if windows else "No active windows found."
+
+
+def manage_window(action: str, window_id: str) -> str:
+    """Close or minimize one window by its xdotool ID."""
+    if not _tool_available("xdotool"):
+        return "Cannot manage windows: xdotool is not installed."
+    normalized = action.strip().lower()
+    command = {"close": "windowclose", "minimize": "windowminimize"}.get(normalized)
+    if command is None or not window_id.strip().isdigit():
+        return "Window action must be close or minimize, with a numeric window ID."
+    try:
+        result = _run(("xdotool", command, window_id.strip()))
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        return f"Window action failed: {exc}"
+    if result.returncode != 0:
+        return f"Window action failed: {result.stderr.strip() or 'xdotool returned an error'}"
+    return f"Window {window_id.strip()} {normalized}d."
+
+
+def system_status() -> str:
+    """Return concise CPU, memory, and battery information."""
+    status: list[str] = []
+    if _tool_available("uptime"):
+        result = _run(("uptime",))
+        if result.returncode == 0:
+            status.append(f"Load: {result.stdout.strip()}")
+    try:
+        memory = _run(("free", "-h"))
+        memory_line = next((line for line in memory.stdout.splitlines() if line.startswith("Mem:")), None)
+        if memory_line:
+            fields = memory_line.split()
+            status.append(f"Memory: {fields[2]} used of {fields[1]}" if len(fields) > 2 else f"Memory: {memory_line}")
+    except (OSError, subprocess.TimeoutExpired):
+        status.append("Memory: unavailable")
+    battery_path = "/sys/class/power_supply"
+    batteries = [entry for entry in os.listdir(battery_path)] if os.path.isdir(battery_path) else []
+    battery = next((entry for entry in batteries if entry.startswith("BAT")), None)
+    if battery:
+        capacity_file = os.path.join(battery_path, battery, "capacity")
+        try:
+            with open(capacity_file, encoding="ascii") as file:
+                status.append(f"Battery: {file.read().strip()}%")
+        except OSError:
+            status.append("Battery: unavailable")
+    else:
+        status.append("Battery: not detected")
+    return "System status:\n" + "\n".join(status)
+
+
+def execute_system_command(command: str) -> str:
+    """Execute a named safe system operation, never an arbitrary shell string."""
+    normalized = command.strip().lower()
+    if normalized in {"status", "system status", "info"}:
+        return system_status()
+    if normalized in {"windows", "list windows", "active windows"}:
+        return list_windows()
+    if normalized in {"volume up", "volume down", "volume mute"}:
+        return adjust_volume(normalized.removeprefix("volume "))
+    return "Unknown system command. Supported commands: status, windows, volume up, volume down, volume mute."

alinux-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "alinux"
+version = "0.1.0"
+description = "Alinux AI orchestration shell for minimal Linux desktops"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Alinux contributors" }]
+keywords = ["ai", "linux", "desktop", "automation", "fluxbox"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: End Users/Desktop",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Python :: 3",
+  "Topic :: Desktop Environment",
+]
+dependencies = [
+  "openai>=1.40.0,<2",
+  "pydantic>=2.7.0,<3",
+]
+
+[project.optional-dependencies]
+dev = [
+  "build>=1.2.0",
+  "pytest>=8.0.0",
+  "ruff>=0.6.0",
+]
+
+[project.scripts]
+alinux = "alinux.main:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["alinux"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

alinux-0.1.0/tests/test_agent.py

@@ -0,0 +1,19 @@
+from alinux.agent import Agent
+
+
+def test_empty_input_returns_safe_response(monkeypatch):
+    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+
+    result = Agent().decide("   ")
+
+    assert result.action == "respond_to_user"
+    assert "Please enter" in result.parameter
+
+
+def test_without_api_key_does_not_call_model(monkeypatch):
+    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+
+    result = Agent().decide("show status")
+
+    assert result.action == "respond_to_user"
+    assert "OPENAI_API_KEY" in result.parameter

alinux-0.1.0/tests/test_agent_provider.py

@@ -0,0 +1,24 @@
+from alinux.agent import Agent
+
+
+def test_groq_provider_selects_builtin_model_and_endpoint(monkeypatch):
+    monkeypatch.setenv("ALINUX_PROVIDER", "groq")
+    monkeypatch.setenv("ALINUX_API_KEY", "test-key")
+
+    agent = Agent()
+
+    assert agent.model == "llama-3.3-70b-versatile"
+    assert agent.base_url == "https://api.groq.com/openai/v1"
+    assert agent.api_key == "test-key"
+
+
+def test_custom_openai_compatible_configuration(monkeypatch):
+    monkeypatch.delenv("ALINUX_PROVIDER", raising=False)
+    monkeypatch.setenv("ALINUX_API_KEY", "custom-key")
+    monkeypatch.setenv("ALINUX_API_BASE_URL", "https://example.test/v1")
+
+    agent = Agent(model="local-model")
+
+    assert agent.model == "local-model"
+    assert agent.base_url == "https://example.test/v1"
+    assert agent.api_key == "custom-key"

alinux-0.1.0/tests/test_fluxbox.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+from alinux.fluxbox import install_fluxbox_menu
+
+
+def test_fluxbox_menu_entry_is_added_once(tmp_path: Path):
+    menu_path = tmp_path / "menu"
+    menu_path.write_text("[begin] (Fluxbox)\n[end]\n", encoding="utf-8")
+
+    install_fluxbox_menu(menu_path)
+    install_fluxbox_menu(menu_path)
+
+    content = menu_path.read_text(encoding="utf-8")
+    assert content.count("[exec] (Open Alinux) {alinux open}") == 1

alinux-0.1.0/tests/test_system_controls.py

@@ -0,0 +1,15 @@
+from alinux import system_controls
+from alinux.agent import AgentAction
+from alinux.main import _dispatch
+
+
+def test_arbitrary_system_commands_are_rejected():
+    result = system_controls.execute_system_command("rm -rf /")
+
+    assert result.startswith("Unknown system command")
+
+
+def test_dispatch_responds_without_desktop_access():
+    result = _dispatch(AgentAction(action="respond_to_user", parameter="Hello"))
+
+    assert result == "Hello"