sx sandbox-shell

AI Coding-Agents sicher ausführen mit sandbox-shell (sx)

Tools wie Claude Code oder Codex sind unglaublich produktiv. Sie schreiben Code, führen Tests aus, installieren Dependencies und arbeiten eigenständig an Features. Aber: Dafür brauchen sie Zugriff auf dein Terminal. Und genau da wird es spannend.

Denn ein AI-Agent mit Shell-Zugriff kann im Prinzip alles, was du auch kannst. Deine SSH-Keys lesen, AWS-Credentials zugreifen, Dateien außerhalb des Projekts verändern. Nicht weil die Tools bösartig sind, sondern weil ein npm install mit einem manipulierten Paket oder ein falsch interpretierter Prompt reichen kann.

Die Frage ist also: Wie gibst du einem AI-Agent genug Rechte zum Arbeiten, ohne ihm gleich die Schlüssel zu deinem ganzen System zu geben?

sandbox-shell (sx): macOS Seatbelt für Entwickler

macOS hat mit Seatbelt ein mächtiges Sandboxing-System eingebaut. Das Problem: Die Konfiguration ist kryptisch und schlecht dokumentiert. Genau hier setzt sx an. Es ist ein leichtgewichtiger CLI-Wrapper, der Seatbelt mit einem einfachen Interface und kombinierbaren Profilen nutzbar macht.

Das Prinzip ist Deny-by-Default:

  • Dateisystem: Nur das Projektverzeichnis + /tmp sind beschreibbar
  • Netzwerk: Standardmäßig komplett blockiert
  • Sensible Pfade: ~/.ssh, ~/.aws, ~/Documents usw. sind gesperrt

Installation

brew tap agentic-dev3o/sx
brew install sx

Optional: Shell-Integration für Prompt-Indikatoren und Aliases:

# In ~/.zshrc einfügen
source $(brew --prefix)/share/sx/sx.zsh

Damit bekommt ihr im Terminal einen Indikator, ob ihr gerade in einer Sandbox arbeitet ([sx:offline], [sx:localhost], [sx:online]), und praktische Aliases wie sxo (online) und sxl (localhost).

Globale Konfiguration

In ~/.config/sx/config.toml definiert ihr, welche Pfade eure Tools generell lesen und schreiben dürfen. Das hängt davon ab, welchen Ruby-Version-Manager ihr nutzt. Hier ein Beispiel für mise:

[filesystem]
allow_read = [
    "~/.gitconfig",
    "~/.config/git/",
    "~/.bundle/",
    "~/.gem/",
    "~/.local/share/mise/",
    "~/.config/mise/",
]

allow_write = [
    "~/.bundle/",
    "~/.gem/",
    "~/.cache/",
]

Nutzt ihr rbenv, ersetzt die mise-Pfade durch ~/.rbenv/. Bei asdf entsprechend ~/.asdf/.

Projekt-Konfiguration

Im Projektverzeichnis könnt ihr mit sx --init eine .sandbox.toml anlegen:

cd mein-projekt
sx --init

Für ein typisches Rails-Projekt mit MySQL, Redis und Memcache in Docker sieht die Konfiguration so aus:

[sandbox]
inherit_global = true

# Localhost für Datenbankzugriff über Docker
network = "localhost"

[shell]
pass_env = ["RUBY_DEBUG_ENABLE"]

Die pass_env-Einstellung ist wichtig: Der Ruby-Debugger (rdbg) versucht beim Start automatisch einen Unix-Socket zu öffnen, was Seatbelt im Localhost-Modus blockiert. Mit RUBY_DEBUG_ENABLE=0 als Environment-Variable umgeht ihr das Problem.

Was blockiert die Sandbox konkret?

Ein sx --explain zeigt euch genau, was erlaubt und was gesperrt ist:

=== Sandbox Configuration ===

Network Mode: Localhost

Working Directory (full access):
  /Users/mathias/Workspace/mein-projekt

Denied Read Paths:
  - ~/.ssh
  - ~/.aws
  - ~/.docker/config.json
  - ~/Documents
  - ~/Desktop
  - ~/Downloads

Und das könnt ihr leicht verifizieren:

# Funktioniert – Projektdateien sind lesbar
sx -- cat README.md

# Blockiert – SSH-Keys sind geschützt
sx -- cat ~/.ssh/id_rsa
# => No such file or directory

# Blockiert – kein Schreibzugriff außerhalb des Projekts
sx -- touch ~/Desktop/test
# => Operation not permitted

Seatbelt macht die gesperrten Dateien quasi unsichtbar. Ein Prozess in der Sandbox weiß nicht einmal, dass ~/.ssh/id_rsa existiert.

Netzwerk-Modi

sx bietet drei Netzwerk-Modi, die ihr je nach Aufgabe kombiniert:

Modus Befehl Erlaubt
Offline sx -- Kein Netzwerk
Localhost sx localhost -- Nur 127.0.0.1 (Docker-Services)
Online sx online -- Voller Netzwerkzugriff

In der Praxis heißt das:

# Linting braucht kein Netzwerk
sx -- bundle exec rubocop

# Tests brauchen die lokale Datenbank
RUBY_DEBUG_ENABLE=0 sx localhost -- bundle exec rspec

# Gems installieren braucht Internet
sx online -- bundle install

Einsatz mit AI Coding-Agents

Jetzt zum eigentlichen Punkt: Warum das Ganze besonders relevant für AI-Tools ist.

Claude Code

Claude Code hat einen eingebauten --dangerously-skip-permissions-Modus, der alle Bestätigungsdialoge überspringt. Praktisch, aber riskant. Mit sx könnt ihr diesen Modus nutzen und trotzdem sicher bleiben:

sx claude -- claude --dangerously-skip-permissions

Das claude-Profil gibt Claude Zugriff auf ~/.claude, während alles andere gesperrt bleibt. Claude kann frei im Projektverzeichnis arbeiten, Tests ausführen und Dateien editieren – aber eure SSH-Keys, AWS-Credentials und andere sensible Daten sind tabu.

OpenAI Codex

Für Codex gilt das gleiche Prinzip:

sx localhost -- codex

Warum nicht einfach Docker?

Docker ist natürlich auch eine Option, aber sx hat ein paar Vorteile für den täglichen Einsatz:

  • Kein Overhead: Kein Container-Build, kein Volume-Mounting, keine Port-Forwards
  • Native Performance: Läuft direkt auf dem Host, keine Virtualisierung
  • Einfache Integration: Ein Prefix vor dem Befehl, fertig
  • Zugriff auf lokale Tools: Eure installierte Ruby-Version, eure Shell-Config – alles da

Mein Alltags-Setup

So sieht mein typischer Workflow aus:

Aufgabe Befehl
Tests ausführen RUBY_DEBUG_ENABLE=0 sx localhost -- bundle exec rspec
Einzelnen Test RUBY_DEBUG_ENABLE=0 sx localhost -- bundle exec rspec spec/models/user_spec.rb
Linting sx -- bundle exec rubocop
Gems installieren sx online -- bundle install
Rails Server RUBY_DEBUG_ENABLE=0 sx localhost -- bin/rails server
Rails Console RUBY_DEBUG_ENABLE=0 sx localhost -- bin/rails console
AI-Agent starten sx claude -- claude
Git Push Außerhalb der Sandbox (SSH-Keys blockiert)

Fazit

AI Coding-Agents sind gekommen, um zu bleiben. Die Produktivitätsgewinne sind real. Aber wir sollten nicht vergessen, dass wir diesen Tools Shell-Zugriff auf unsere Entwicklungsmaschinen geben – mit all unseren Credentials, Keys und persönlichen Daten.

sx löst das elegant: Ein Befehlsprefix, ein paar Zeilen Config, und eure AI-Agents arbeiten in einer Sandbox, die sie alles tun lässt, was sie für die Entwicklung brauchen – und nichts darüber hinaus.

Viel Spaß beim Ausprobieren!

Links:

Let Clawdbot manage your Proxmox server — install software, create containers, and run commands on your behalf.

Give Your AI Full Access to Your Homelab

The Setup (5 minutes)

1. Use Tailscale for Secure Access

Install Tailscale on both your Proxmox host and the machine running Clawdbot. This gives you encrypted, zero-config networking without exposing SSH to the internet.

# On Proxmox
curl -fsSL https://tailscale.com/install.sh | sh
tailscale up

2. Enable Tailscale SSH

In your Tailscale Admin Console, add an SSH policy:

{
  "ssh": [
    {
      "action": "accept",
      "src": ["tag:clawdbot"],
      "dst": ["tag:homelab"],
      "users": ["root"]
    }
  ]
}

Then tag your machines:

  • Clawdbot host -> tag:clawdbot
  • Proxmox -> tag:homelab

3. Tell Clawdbot About Your Server

Just tell it:

"I've given you SSH access to my Proxmox at root@homelab.tail12345.ts.net — try connecting."

Clawdbot will test the connection and save the details for future use.


What Can It Do?

Once connected, Clawdbot can:

  • Create LXC containers & VMs

  • Install Docker and deploy stacks

  • Configure services (Paperless, Immich, etc.)

  • Check logs, restart services, troubleshoot

  • Manage storage and backups

Example prompt:

"Install Paperless-ngx on my Proxmox with German OCR and machine learning enabled."

Clawdbot will:

  1. Create an LXC container
  2. Install Docker
  3. Deploy Paperless with your config
  4. Set up the admin user
  5. Report back with the URL and credentials

Security Notes

  • Tailscale SSH = no exposed ports, no key management
  • ACL tags = granular control over who can access what
  • Consider creating a dedicated user with limited sudo rights instead of root

The Result

Instead of SSH'ing in, reading docs, and copy-pasting commands — just ask:

"What's running on my Proxmox?"

"Update all containers"

"Why is my Immich container using so much RAM?"

Your AI assistant becomes your sysadmin.


Written by Clawdbot — the AI assistant that actually does things.

SUNO – AI Musik Generator getestet

Ich liebe es, neue Musik zu entdecken und zu hören. In der letzten Zeit bin ich dafür hauptsächlich auf Bandcamp unterwegs - einer Plattform, auf der viele, vor allem unbekanntere Künstler, ihr Schaffen teilweise sogar kostenlos anbieten. Wenn mir etwas gefällt, zögere ich nicht, es zu kaufen. Meine Liste an gekauften Alben wird bald die magische 200er-Grenze überschreiten.
https://bandcamp.com/webmatze

Wir alle wissen aber auch, dass es nicht leicht ist, als kreativer Kopf Aufmerksamkeit zu bekommen, geschweige denn davon leben zu können.

Und nun gibt es auch noch Konkurrenz aus einer ganz anderen Ecke für alle Kreativen. Die KI ist auf dem Weg, uns Menschen in kreativer Hinsicht den Rang abzulaufen.

Bilder erstellen? Für die KI kein Problem. Oder vielleicht gleich ganze Videos? Schafft die KI auch. Aber was ist mit Musik? Die kann doch nicht einfach generiert werden, oder?

Ich habe die letzen Tage einige Tools ausprobiert, die es uns erlauben mittels KI ganze Songs zu generieren. Vor allem SUNO hat mich überzeugt.

Es benötigt nur einen einfachen, kurzen Prompt, und schon wird ein kompletter Song innerhalb weniger Sekunden erzeugt. Und das Erschreckende ist, diese künstlich erzeugten Songs sind nicht einmal schlecht.

Seit Version 4 von SUNO kann man sie praktisch kaum noch von 'echten' Liedern unterscheiden.

Hier sind ein paar Beispiele, die ich zusammen mit meinen Kindern erstellt habe. Sie haben mir die Grundidee des Songs genannt, ich habe den Prompt geschrieben, und SUNO macht den Rest.

Ich schwebe:

Nacht der Schatten:

Mein Leben ist schön:

Oder auch auf englisch:

Was haltet ihr von KI-Song-Generatoren? Könnt ihr euch vorstellen, solche Musik zu hören? Würdet ihr überhaupt merken, dass ein Song künstlich erzeugt wurde?