multi platform support

.github/workflows/release.yml

@@ -0,0 +1,54 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: macos-latest   # arm64 (Apple Silicon)
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Go
+        uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+          cache: true
+
+      - name: Build
+        run: make all
+
+      - name: Package
+        run: |
+          VERSION="${GITHUB_REF_NAME}"
+          ARCHIVE="night-agent-${VERSION}-darwin-arm64.tar.gz"
+
+          mkdir -p dist
+          cp nightagent guardian-shim guardian-intercept.dylib dist/
+          cp -r configs dist/
+
+          tar -czf "${ARCHIVE}" -C dist .
+          shasum -a 256 "${ARCHIVE}" | awk '{print $1}' > "${ARCHIVE}.sha256"
+
+          echo "ARCHIVE=${ARCHIVE}" >> "$GITHUB_ENV"
+          echo "VERSION=${VERSION}" >> "$GITHUB_ENV"
+
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          if gh release view "${VERSION}" &>/dev/null; then
+            gh release upload "${VERSION}" "${ARCHIVE}" "${ARCHIVE}.sha256" --clobber
+          else
+            gh release create "${VERSION}" \
+              --title "Night Agent ${VERSION}" \
+              --generate-notes \
+              "${ARCHIVE}" \
+              "${ARCHIVE}.sha256"
+          fi

.gitignore

@@ -0,0 +1,20 @@
+# Binaries (solo root, non directory col nome)
+/nightagent
+/night-agent
+/guardian
+/guardian-shim
+/guardian-intercept.dylib
+
+# macOS
+.DS_Store
+
+# Go
+*.test
+*.out
+/vendor/
+
+# Night Agent config locale
+.nightagent/
+
+# Documenti privati (non versionati)
+docs/private/

CLAUDE.md

@@ -4,106 +4,143 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-**AI Guardian** è un CLI tool per macOS che funge da runtime security layer per agenti AI (Claude Code, Codex, ecc.). Intercetta e governa le azioni degli agenti prima che vengano eseguite. Il progetto è attualmente in fase di pianificazione/design — il codice è ancora da scrivere.
+**Night Agent** è un CLI tool per macOS che funge da runtime security layer per agenti AI (Claude Code, Codex, ecc.). Intercetta e governa le azioni degli agenti prima che vengano eseguite.
 
-Documento di specifica completo: [docs/ai-agent-guardian-mvp-plan.md](docs/ai-agent-guardian-mvp-plan.md)
+Documento di specifica completo: [docs/ai-night-agent-mvp-plan.md](docs/ai-night-agent-mvp-plan.md)
 
-## Tech Stack Pianificato
+**Stato attuale: Cycle 1 ✅ + Cycle 2 ✅ + Cycle 3 ✅**
 
-- **Linguaggio**: Go (single binary, process handling, cross-platform)
+## Tech Stack
+
+- **Linguaggio**: Go (single binary) + C (shim + dylib)
 - **Config**: YAML
-- **Logging**: SQLite o JSONL
-- **Packaging**: Homebrew tap
-- **Sandbox (Cycle 2)**: Docker Desktop
+- **Logging**: JSONL
+- **Sandbox**: Docker Desktop (Cycle 2)
+- **Packaging**: Homebrew tap (futuro)
+
+## Struttura del Progetto
+
+```
+cmd/guardian/          CLI principale (Cobra) — init, run, start, logs, policy, doctor, sandbox, uninstall
+internal/
+  policy/              Policy engine — load/evaluate YAML, glob/regex matching, SandboxConfig
+  audit/               Audit logger — JSONL append-only, filtri decision/action_type, campi sandbox + risk
+  daemon/              Unix socket server — valuta policy, gestisce sandbox Docker, routing decisioni
+  sandbox/             Sandbox manager — docker run wrapper, resolveDockerBinary, BuildDockerArgs
+  scorer/              Risk scorer — heuristics pesate, anomaly burst detection (Cycle 3)
+  suggestions/         Policy suggestion engine — hints contestuali su path, override, anomalie (Cycle 3)
+  shim/                PATH shim — CreateSymlinks, ShimmedCommands (include python/python3)
+  intercept/           DYLD injection — per agenti senza Hardened Runtime
+  interception/        Normalizer — classifica comandi in shell/git/file
+  shell/               Hook injector — preexec in .zshrc, gestisce block + sandbox response
+  wizard/              Setup wizard — UI ASCII art + progress bar
+  policyeditor/        Policy CRUD — toggle/add/remove rules
+  launchagent/         LaunchAgent macOS — autostart al login
+configs/
+  default_policy.yaml  Policy di default con regole Cycle 1 + Cycle 2 (sandbox)
+```
 
 ## Architettura — 5 Layer Logici
 
 ```
 Agente AI
     ↓
-[Interception Layer]  ← cattura shell commands, file ops, git ops, processi
+[Interception Layer]  ← PATH shims + DYLD injection + shell hook preexec
     ↓
-[Policy Engine]       ← valuta regole YAML → decisione: allow / block / ask / sandbox
+[Policy Engine]       ← valuta regole YAML → allow / block / ask / sandbox
     ↓
-[Execution Layer]     ← esegue azioni approvate (locale o isolato)
+[Execution Layer]     ← locale (allow) · bloccato (block) · Docker isolato (sandbox)
     ↓
-[Audit Layer]         ← log con timestamp, decisione, motivo, contesto
+[Audit Layer]         ← JSONL con campi sandbox (sandboxed, sandbox_image, sandbox_exit_code)
     ↑
-[Config & UX Layer]   ← CLI per init, logs, policy edit, approve
+[Config & UX Layer]   ← CLI completo
 ```
 
-## CLI Commands Pianificati
+## CLI Commands Implementati
 
 ```bash
-guardian init          # Inizializza progetto con policy di default
-guardian run           # Esegue agente con protezione attiva
-guardian logs          # Visualizza audit trail
-guardian policy edit   # Modifica regole di policy
-guardian doctor        # Diagnostica e verifica setup
-guardian sandbox run   # Esegue in container isolato (Cycle 2)
+nightagent init [--yes]         # Setup + wizard policy
+nightagent start                # Avvia daemon (Unix socket)
+nightagent run <agente>         # Avvia agente con interception attiva
+nightagent sandbox run <cmd>    # Esegui comando in Docker sandbox (Cycle 2)
+  --image <img>                 # Immagine Docker (default: alpine:3.20)
+  --network <net>               # Rete: none (default) o bridge
+nightagent logs [--decision] [--type] [--limit] [--json]
+nightagent policy list|toggle|add|remove
+nightagent doctor               # Check installazione + Docker status
+nightagent uninstall
+nightagent help
 ```
 
 ## Policy Model
 
 ```yaml
+version: 1
 rules:
   - id: block_sudo
     when: {action_type: shell, command_matches: ["sudo *"]}
+    match_type: glob
     decision: block
-    reason: "sudo disabled"
-
-  - id: ask_git_push_main
-    when: {action_type: git, command_matches: ["git push origin main"]}
-    decision: ask
-    reason: "push to protected branch"
+    reason: "sudo disabilitato"
+
+  - id: sandbox_python_scripts
+    when: {action_type: shell, command_matches: ["python3 *.py"]}
+    match_type: glob
+    decision: sandbox
+    sandbox:
+      image: "python:3.12-alpine"
+      network: "none"
+    reason: "script Python in ambiente isolato"
 ```
 
-Decisioni possibili: `allow`, `block`, `ask`, `sandbox`
+Decisioni: `allow`, `block`, `ask` (= block a runtime), `sandbox`
+
+## Comportamento Sandbox (Cycle 2)
+
+Quando il policy engine restituisce `sandbox`:
+
+1. Il daemon verifica che Docker sia disponibile (`resolveDockerBinary` — cerca anche in path fissi macOS)
+2. Avvia `docker run --rm --network <net> -v <workdir>:/workspace:rw -w /workspace <image> sh -c <cmd>`
+3. I path host nel comando vengono riscritti (`workdir` → `/workspace`)
+4. Cattura stdout/stderr/exit code
+5. Restituisce risposta `{"decision":"sandbox","exit_code":N,"output":"..."}` al shim
+6. Il shim stampa `[⬡ sandbox] <cmd> — <reason>` su stderr e propaga l'exit code
+7. L'evento viene loggato con `sandboxed: true`, `sandbox_image`, `sandbox_exit_code`
+
+Fail-safe: se Docker non è disponibile → blocca con messaggio esplicito.
 
 ## Roadmap
 
-- **Cycle 1 (MVP)**: Policy engine rule-based, intercettazione shell + git, audit log
-- **Cycle 2**: Docker sandbox integration, network isolation
-- **Cycle 3**: Risk scoring, anomaly detection, policy suggestions
+- **Cycle 1** ✅ — Policy engine, PATH shims, DYLD, shell hook, audit log, LaunchAgent
+- **Cycle 2** ✅ — Docker sandbox, `nightagent sandbox run`, routing automatico, path rewriting
+- **Cycle 3** ✅ — Risk scorer (heuristics), anomaly detection, policy suggestions, risk score in logs
 
 ## Repository & Git Workflow
 
-- **Remote**: [github.com/pietroperona/agent-guardian](https://github.com/pietroperona/agent-guardian)
-- **Branch principali**:
-  - `main` — produzione, solo merge da feature branch o staging
-  - `develop` — sviluppo locale
-  - `staging` — ambiente di staging (futuro)
-- **Feature branch**: ogni funzione specifica ha il suo branch (`feature/nome`), poi merge su `main`
+- **Remote**: [github.com/night-agent-cli/night-agent](https://github.com/night-agent-cli/night-agent)
+- **Branch principali**: `main` (produzione), `develop`
 - **Commit**: non citare mai il nome di strumenti AI nei messaggi di commit
 
 ## Approccio di Sviluppo — TDD
 
 Tutto lo sviluppo segue **Test-Driven Development**:
 
-1. Scrivi il test che descrive il comportamento atteso (red)
+1. Scrivi il test (red)
 2. Scrivi il codice minimo per farlo passare (green)
-3. Refactoring se necessario (refactor)
-
-In Go, ogni package ha il suo file `_test.go`. Eseguire i test con:
+3. Refactoring se necessario
 
 ```bash
-go test ./...              # tutti i test
-go test ./internal/policy  # test di un package specifico
+go test ./...                        # tutti i test
+go test ./internal/sandbox/...       # solo sandbox
 go test -run TestNomeFunzione ./...  # singolo test
+make                                 # build completo (dylib + shim + nightagent)
 ```
 
 ## Principi di Design Fondamentali
 
 1. Controlla **azioni**, non intenzioni
 2. **Determinismo** prima di intelligenza — no ML per decisioni hard
 3. **Explainability** — l'utente deve sempre capire perché qualcosa è bloccato
-4. **Safe failure mode** — in caso di errore del guardian, blocca (non permette)
+4. **Safe failure mode** — in caso di errore, blocca (non permette)
 5. Security by default, friction minimale
 6. Framework-agnostic — funziona con qualsiasi agente AI
-
-## Superfici da Proteggere (Scope MVP)
-
-- Shell commands pericolosi (`rm -rf`, `curl | bash`, `chmod 777`, ecc.)
-- File operations su path sensibili (`~/.ssh`, `~/.aws`, `.env`)
-- Git operations (`git push --force`, push su main/master)
-- Installazione package/processi non autorizzati

Formula/night-agent.rb

@@ -0,0 +1,76 @@
+class NightAgent < Formula
+  desc "Runtime security layer for AI agents on macOS"
+  homepage "https://github.com/night-agent-cli/night-agent"
+  url "https://github.com/night-agent-cli/night-agent/archive/refs/tags/v0.2.2.tar.gz"
+  sha256 "0019dfc4b32d63c1392aa264aed2253c1e0c2fb09216f8e2cc269bbfb8bb49b5"
+  license "MIT"
+  head "https://github.com/night-agent-cli/night-agent.git", branch: "main"
+
+  depends_on "go" => :build
+  depends_on :macos
+
+  def install
+    # Compila il binario principale Go
+    system "go", "build", "-o", bin/"nightagent", "./cmd/guardian"
+
+    # Compila lo shim C (intercettazione comandi via PATH)
+    system "clang", "-o", libexec/"guardian-shim",
+           "internal/shim/csrc/guardian_shim.c",
+           "-Wall", "-Wextra", "-Wno-unused-parameter"
+
+    # Compila la dylib DYLD_INSERT_LIBRARIES (opzionale, per intercettazione avanzata)
+    system "clang", "-dynamiclib",
+           "-o", lib/"guardian-intercept.dylib",
+           "internal/intercept/csrc/guardian_intercept.c",
+           "-Wall", "-Wextra", "-Wno-unused-parameter",
+           "-current_version", "1.0",
+           "-compatibility_version", "1.0"
+
+    # Installa la policy di default
+    pkgshare.install "configs"
+
+    # Crea symlink per lo shim nella libexec
+    (libexec/"shims").mkpath
+  end
+
+  def post_install
+    # Copia la policy di default se non esiste già
+    guardian_dir = Pathname.new(ENV["HOME"]) / ".night-agent"
+    policy_dest = guardian_dir / "policy.yaml"
+    policy_src = pkgshare / "configs" / "default_policy.yaml"
+
+    unless policy_dest.exist?
+      guardian_dir.mkpath
+      FileUtils.cp policy_src, policy_dest
+      policy_dest.chmod(0600)
+    end
+  end
+
+  def caveats
+    <<~EOS
+      Night Agent è stato installato. Per completare la configurazione:
+
+      1. Inizializza Night Agent:
+           nightagent init
+
+      2. Per le funzionalità sandbox, installa Docker Desktop:
+           https://www.docker.com/products/docker-desktop/
+         Avvialo almeno una volta manualmente dopo l'installazione.
+
+      3. Riavvia il terminale o esegui:
+           source ~/.zshrc
+
+      Per verificare che tutto funzioni:
+           nightagent doctor
+    EOS
+  end
+
+  test do
+    # Test che il binario risponde correttamente
+    output = shell_output("#{bin}/nightagent --help")
+    assert_match "nightagent", output
+
+    # Test che la policy di default è accessibile
+    assert_predicate pkgshare / "configs" / "default_policy.yaml", :exist?
+  end
+end