> ## Documentation Index
> Fetch the complete documentation index at: https://docs.corgea.app/llms.txt
> Use this file to discover all available pages before exploring further.

# CLI

> Application Security direkt über die CLI

## Einführung

Die Corgea CLI ist ein leistungsstarkes Entwicklungstool, mit dem Sie Schwachstellen in Ihrem Code finden und beheben können. Corgea identifiziert mithilfe des KI-gestützten Scanners BLAST komplexe Sicherheitsprobleme wie Fehler in der Geschäftslogik, Authentifizierungsschwachstellen und andere schwer erkennbare Bugs. Über die CLI können Sie Ihre Codebasis scannen, Befunde untersuchen, Fixes anwenden und vieles mehr – mit einem auf Entwickler zugeschnittenen Bedienkonzept.

<Tip>
  **Erweitern Sie Ihren KI-Coding-Agenten.** Die Corgea CLI bildet auch die Grundlage für unsere [agentenbasierten Integrationen](/de/agentic_integrations): Installieren Sie den Corgea Agent Skill und lassen Sie Ihren KI-Agenten (Cursor, Claude Code, Copilot und weitere) Schwachstellen für Sie scannen, priorisieren und beheben.
</Tip>

## Funktionen

* **Unterstützung mehrerer Scanner**: Scannen Sie mit BLAST (unserem KI-gestützten Scanner) und laden Sie Berichte von Semgrep, Snyk, Checkmarx, CodeQL, Fortify und Coverity hoch.
* **Issue-Management**: Listen Sie Sicherheitsbefunde auf, untersuchen und verwalten Sie sie.
* **Fix-Integration**: Zeigen Sie KI-generierte Fixes für Schwachstellen direkt in Ihrem Terminal an und wenden Sie sie an.
* **Abhängigkeitsanalyse**: Erstellen Sie Offline-Abhängigkeitsinventare, prüfen Sie Abhängigkeitsdiagramme, generieren Sie SBOMs und bewerten Sie Abhängigkeitsrichtlinien mit [`corgea deps`](/de/cli/deps).
* **Prüfung von Package Advisories**: Prüfen Sie bekannte Sicherheitshinweise, bevor Sie ein npm- oder PyPI-Paket auswählen oder installieren.
* **Package Manager Install Gate**: Prüfen Sie Installationen mit `npm`, `yarn`, `pnpm`, `pip` und `uv` auf bekanntermaßen anfällige, bösartige oder verdächtig neue Pakete, bevor diese in das Projekt gelangen – siehe [Package Manager Install Gate](#package-manager-install-gate).
* **Flexible Ausgabe**: Unterstützung sowohl für menschenlesbare als auch JSON-Ausgabeformate für einfachere CI-Integrationen.
* **CI/CD-Integration**: Lassen Sie Builds abhängig von Schweregraden oder benutzerdefinierten Blocking Rules fehlschlagen.
* **Scan-Verwaltung**: Verfolgen Sie den Scan-Fortschritt und die Ergebnisse Ihrer Projekte.
* **Installation von Agent Skills**: Installieren Sie freigegebene Agent Skills aus der Corgea Registry in unterstützten Coding-Agenten.

## Voraussetzungen

* **Corgea-Konto**: Ein aktives Corgea-Konto.
* **Token zur Authentifizierung**: Ein gültiges Corgea-API-Token oder JWT-Zugriffstoken.

Die Offline-Befehle `corgea deps scan`, `graph`, `explain`, `diff`, `sbom` und `policy init` benötigen weder ein Corgea-Konto noch ein Token, eine Konfiguration oder Netzwerkzugriff.

## Installationsanleitung

### Mit npm installieren

```bash theme={null}
npm install -g @corgea/cli
```

Das npm-Paket bündelt native Binärdateien für unterstützte Plattformen und wählt zur Laufzeit die richtige Binärdatei für Ihr Betriebssystem und Ihre Architektur aus.

### Mit uv installieren

Für Python-Benutzer ist dies die bevorzugte Installationsmethode. `uv tool install` erstellt eine isolierte Tool-Umgebung aus dem PyPI-Paket und stellt die CLI als `corgea` auf Ihrem `PATH` bereit.

```bash theme={null}
uv tool install corgea-cli
```

Wenn `uv` meldet, dass sein Tool-Verzeichnis nicht auf Ihrem `PATH` ist, führen Sie aus:

```bash theme={null}
uv tool update-shell
```

### Mit pip installieren

Wenn Sie `uv` nicht verwenden, können Sie die Corgea-CLI mit dem Python-Paketinstaller pip installieren:

```bash theme={null}
pip install corgea-cli
```

Dieser Befehl lädt das Corgea-CLI-Paket von PyPI (Python Package Index) herunter und installiert es auf Ihrem System. Weitere Details zum Paket finden Sie auf seiner PyPI-Seite: [https://pypi.org/project/corgea-cli/](https://pypi.org/project/corgea-cli/).

### Mit Homebrew installieren

Um das Corgea-CLI-Tool mit Homebrew zu installieren, fügen Sie zuerst den Corgea-Tap hinzu und installieren dann die CLI:

<CodeGroup>
  ```bash MacOS theme={null}
  brew tap Corgea/cli
  brew install corgea-cli
  ```
</CodeGroup>

### Manuell installieren

Laden Sie das Archiv für Ihre Plattform aus dem [neuesten Release](https://github.com/Corgea/cli/releases/latest) herunter, entpacken Sie es und verschieben Sie die Binärdatei `corgea` in ein Verzeichnis in Ihrem `PATH`. Die folgenden `latest/download`-URLs verweisen stets auf das neueste Release.

<CodeGroup>
  ```bash macOS (Apple Silicon) theme={null}
  curl -L https://github.com/Corgea/cli/releases/latest/download/corgea-aarch64-apple-darwin.zip -o corgea.zip && unzip corgea.zip
  chmod +x corgea
  sudo mv corgea /usr/local/bin
  ```

  ```bash macOS (Intel) theme={null}
  curl -L https://github.com/Corgea/cli/releases/latest/download/corgea-x86_64-apple-darwin.zip -o corgea.zip && unzip corgea.zip
  chmod +x corgea
  sudo mv corgea /usr/local/bin
  ```

  ```bash Linux (x86_64) theme={null}
  curl -L https://github.com/Corgea/cli/releases/latest/download/corgea-x86_64-unknown-linux-gnu.zip -o corgea.zip && unzip corgea.zip
  chmod +x corgea
  sudo mv corgea /usr/local/bin
  ```

  ```bash Linux (ARM64) theme={null}
  curl -L https://github.com/Corgea/cli/releases/latest/download/corgea-aarch64-unknown-linux-gnu.zip -o corgea.zip && unzip corgea.zip
  chmod +x corgea
  sudo mv corgea /usr/local/bin
  ```

  ```bash Windows (x64) theme={null}
  # Download the latest Windows build, extract it, and move corgea.exe to a directory on your PATH:
  https://github.com/Corgea/cli/releases/latest/download/corgea-x86_64-pc-windows-msvc.zip
  ```
</CodeGroup>

Eine statisch verlinkte Linux-Version wird ebenfalls als `corgea-x86_64-unknown-linux-musl.zip` veröffentlicht.

## Authentifizierung

### Über die CLI anmelden

Führen Sie zur Authentifizierung den folgenden Befehl aus. Sie werden zur Webanwendung weitergeleitet, um die CLI zu autorisieren:

```bash theme={null}
corgea login
```

#### Mit benutzerdefiniertem Scope anmelden (für Single-Tenant-Instanzen)

**Hinweis:** Der Unternehmens-Scope entspricht Ihrer Corgea-Subdomain, zum Beispiel `https://your-company.corgea.app`.

```bash theme={null}
corgea login --scope your-company
```

#### Mit Token anmelden (API-Token oder JWT)

Verwenden Sie für automatisierte Pipelines und CI/CD-Umgebungen die Token-Authentifizierung, um sich zuverlässig und nicht interaktiv anzumelden. Sie können ein Corgea-API-Token oder ein JWT-Zugriffstoken übergeben:

```bash theme={null}
corgea login YOUR_TOKEN
```

Sie können das Token auch in einer Umgebungsvariable setzen:

<CodeGroup>
  ```bash MacOS/Unix theme={null}
  export CORGEA_TOKEN="your-token-here"
  corgea login
  ```

  ```bash Windows theme={null}
  $env:CORGEA_TOKEN="your-token-here"
  corgea login
  ```
</CodeGroup>

#### Auf eine Single-Tenant-Instanz verweisen

Bei einer Single-Tenant-Instanz müssen Sie die CLI mit der Option `--url` auf Ihre Instanz verweisen:

```bash theme={null}
corgea login --url https://<<Your Instance>>.corgea.app YOUR_TOKEN
```

Sie können die URL auch in einer Umgebungsvariable setzen, und die CLI erkennt sie automatisch:

<CodeGroup>
  ```bash MacOS/Unix theme={null}
  export CORGEA_URL="https://<<Your Instance>>.corgea.app"
  export CORGEA_TOKEN="your-token-here"
  corgea login
  ```

  ```bash Windows theme={null}
  $env:CORGEA_URL="https://<<Your Instance>>.corgea.app"
  $env:CORGEA_TOKEN="your-token-here"
  corgea login
  ```
</CodeGroup>

## Verwendung

### Befehle und Optionen

#### Package Advisories prüfen

Mit `corgea advisories check` prüfen Sie bekannte Sicherheitshinweise, bevor Sie ein npm- oder PyPI-Paket auswählen oder installieren. Eine Prüfung ohne Versionsangabe listet den Advisory-Verlauf des Pakets auf. Geben Sie eine exakte Version an, um eine Bewertung für dieses Release zu erhalten.

```bash theme={null}
corgea advisories check npm axios
corgea advisories check npm axios@0.21.0
corgea advisories check pypi requests==2.31.0
```

Als Ecosystem sind `npm` und `pypi` zulässig; `pip` wird als Alias akzeptiert. npm-Versionen müssen vollständig und exakt angegeben werden, beispielsweise `1.2.3`. Versionsbereiche, Tags und Teilversionen werden nicht unterstützt. Bei PyPI können Sie `package@version` oder die pip-Syntax `package==version` verwenden.

Ergebnisse ohne Versionsangabe helfen Ihnen, vor der Auswahl einer Version den Advisory-Verlauf zu prüfen. Ergebnisse für eine exakte Version enthalten bekannte Advisory-Details, gegebenenfalls Informationen zu korrigierten Versionen und eine Empfehlung für eine sichere Version, sofern alle gemeldeten Advisories einen Fix aufweisen. Der schreibgeschützte Befehl benötigt Netzwerkzugriff; die Installation wird weiterhin über das [Package Manager Install Gate](#package-manager-install-gate) abgesichert.

Mit `--json` erhalten Sie eine maschinenlesbare Antwort nach Schemaversion 1. Der Exit-Code lautet `0`, wenn keine Advisories gefunden wurden, `1` bei vorhandenen Advisories und `2` bei einem Fehler. Ist ein Paket nicht in der Advisory-Datenbank vorhanden, wird ebenfalls Exit-Code `0` zurückgegeben.

#### Package Manager Install Gate

Verwenden Sie `corgea npm`, `corgea yarn`, `corgea pnpm`, `corgea pip` oder `corgea uv`, um unterstützte Paketmanager-Installationsbefehle über Corgea auszuführen, bevor Abhängigkeiten installiert werden.

```bash theme={null}
corgea npm install axios@0.21.0
corgea yarn add lodash
corgea pnpm install express
corgea pip install requests==2.31.0
corgea uv add requests
```

Corgea prüft jede aufgelöste Version anhand öffentlicher Schwachstellendaten auf bekanntermaßen anfällige oder bösartige Releases – ohne Token – und blockiert ungewöhnlich neue Releases (siehe **Recency Gate** unten). Anfällige, bösartige oder zu neue Versionen stoppen die Installation, bevor der Paketmanager ausgeführt wird. Wrapper-Flags stehen zwischen dem Namen des Paketmanagers und dessen Befehl, beispielsweise `corgea pip --force install requests`.

| Flag      | Beschreibung                                                                                                                                                                                            |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--force` | Trotz aller Befunde fortfahren (anfällig, bösartig, nicht verifizierbar oder zu neu). Umgeht auch vorab erkannte Ausschlussgründe: einen falschen Paketmanager und extern verwaltete Python-Umgebungen. |
| `--json`  | Einen maschinenlesbaren Bericht ausgeben (mit `verdict_mode` als `public` oder `authenticated`) anstelle von menschenlesbarem Text (siehe unten).                                                       |

**Recency Gate.** Zusätzlich zu Schwachstellendaten blockiert Corgea jedes ausdrücklich angegebene Installationsziel, dessen aufgelöste Version innerhalb eines definierten Zeitfensters veröffentlicht wurde. So lassen sich kurz zuvor veröffentlichte Typosquatting-Pakete und Paketübernahmen abfangen, bevor Advisory-Feeds reagieren. Das Gate ist **standardmäßig aktiviert** und verwendet ein Zeitfenster von 14 Tagen. Konfigurieren Sie es in `~/.corgea/config.toml` (`recency_gate = false` zum Deaktivieren, `recency_threshold_days` zum Anpassen des Zeitfensters) oder über `CORGEA_RECENCY_GATE` und `CORGEA_RECENCY_THRESHOLD_DAYS`. Pakete ohne ermittelbares Veröffentlichungsdatum lösen das Gate nicht aus. Die Bewertung als anfällig oder bösartig hat Vorrang vor dem Alter; `--force` umgeht das Gate für eine einzelne Installation.

**Abdeckung.** `pip install` und `npm install` lösen die gesamte vorgesehene Installation einschließlich transitiver Abhängigkeiten auf. Dadurch blockiert auch eine anfällige transitive Abhängigkeit den Befehl. Schlägt der Dry-Run-Resolver fehl, gibt Corgea eine Warnung aus und prüft stattdessen die ausdrücklich angegebenen Pakete. `npm ci` wird anhand der Lockdatei des Projekts und `uv sync` anhand von `uv.lock` geprüft. Somit wird der vollständige gesperrte Abhängigkeitsbestand geprüft, obwohl die Befehle keine Paketnamen enthalten. Das `uv`-Gate erfasst außerdem ausdrücklich angegebene Ziele für `uv add ...` und `uv pip install ...`; `uv lock` wird unverändert ausgeführt, da es nichts installiert. `yarn` und `pnpm` prüfen nur ausdrücklich angegebene Ziele, weil kein sicherer Dry-Run-Resolver verfügbar ist.

**Installationen ohne Paketangabe.** Ein einfaches `npm install` wird anhand der `package.json` des Projekts geprüft. Einfache `yarn`- und `pnpm`-Aufrufe sowie installierende `uv`-Befehle können nicht vorab geprüft werden. Corgea weist darauf hin und führt sie ungeprüft aus.

```bash theme={null}
corgea npm install
corgea yarn install
corgea pnpm install
corgea uv add
```

**Öffentlicher und authentifizierter Modus.** Ohne Token arbeitet das Gate im öffentlichen Modus: Anfällige und bösartige Pakete werden blockiert, nicht verifizierbare Pakete und Abfragefehler führen jedoch nur zu Warnungen und lassen die Installation zu. Wiederholte Fehler werden in einer Zusammenfassungszeile gebündelt. Mit einem Token aus `CORGEA_TOKEN` oder `corgea login` und der standardmäßigen Vulnerability API arbeitet das Gate im authentifizierten Modus nach dem Fail-Closed-Prinzip. Nicht verifizierbare Pakete, Fehler bei der Abhängigkeitsauflösung, Ausfälle der Vulnerability API und eine unvollständige Baumabdeckung bei Paketmanagern, die normalerweise den vollständigen Baum auflösen (`pip`, `npm`, `uv`), blockieren die Installation, sofern Sie nicht `--force` angeben.

**Benutzerdefinierte Vulnerability API.** Wenn `CORGEA_VULN_API_URL` auf einen benutzerdefinierten Endpunkt verweist, sendet Corgea Ihr Token nicht dorthin; das Gate bleibt deshalb im öffentlichen Modus. Mit `CORGEA_VULN_API_SEND_TOKEN_TO_CUSTOM_URL=1` aktivieren Sie die authentifizierte Durchsetzung für einen Endpunkt, dem Sie vertrauen.

**Extern verwaltetes Python.** Für `pip` verweigert Corgea Installationen in extern verwalteten Umgebungen (PEP 668), bevor die Registry-Prüfungen durchgeführt werden. Aktivieren Sie eine virtuelle Umgebung oder übergeben Sie `--force`, um dies zu umgehen.

Corgea führt den passenden Paketmanager von Ihrem `PATH` aus. Für `corgea pip ...` versucht es `pip3`, wenn `pip` fehlt; wenn keiner existiert, beendet die CLI `127` und nennt die fehlende Binärdatei.

**Befunde.** Wenn ein aufgelöstes Paket anfällig ist, zeigen die Befunde im Abhängigkeitsbaum dessen Herkunft:

* `(from requirements)` — über eine pip-Anforderungsdatei angefordert.
* `(already in package.json)` — bereits eine direkte npm-Abhängigkeit.
* `(transitive)` — über eine andere Abhängigkeit eingebunden.

Ist das ausdrücklich angegebene Paket nicht anfällig, enthält der aufgelöste Baum aber bereits ein anfälliges Paket, nennt die Ablehnung den vorhandenen Baum als Quelle. Advisory-Zeilen zeigen die angegebene korrigierte Version oder weisen darauf hin, dass keine bekannt ist. Sind für alle Advisories eines Pakets Fixdaten vorhanden, gibt Corgea `safe version: axios@0.21.2` aus. Bei anfälligen direkten npm-Abhängigkeiten kann zusätzlich `fix with: corgea npm install package-name@version (advertised fix)` erscheinen. Anzahl der Schwachstellen und Exit-Verhalten richten sich nach dem ursprünglichen Installationsziel.

**JSON-Ausgabe.** `--json` gibt einen einzelnen Bericht auf stdout aus und leitet stdout des Paketmanagers nach stderr um, sodass stdout ausschließlich Corgea gehört. Schemaversion **2** enthält `manager`, `subcommand`, `args`, `recency_threshold_days` (das aktive Zeitfenster oder `null`, wenn das Gate deaktiviert ist; zusammen mit `age_seconds` des jeweiligen Ergebnisses zu verwenden), eine nach `named` und `tree` aufgeteilte `summary`, `verdict_mode`, ein `results`-Array und bei ausgeführter Baumauflösung ein `tree`-Objekt. Baumeinträge haben für `origin` den Wert `requested`, `pre-existing` oder `transitive`. Bekanntermaßen bösartige Pakete verwenden den separaten `status` `malicious`, einen booleschen Wert `malware` pro Treffer und einen eigenen Zähler `malicious` in jedem Zusammenfassungsobjekt. `remediation` ist für sie immer `null`, da das Paket entfernt und nicht aktualisiert werden sollte. Bei anfälligen Paketen wird eine sichere Version weiterhin nur angegeben, wenn sie sämtliche Advisories abdeckt.

#### Agent Skills installieren

Installieren Sie einen freigegebenen Skill aus der Corgea Registry in das Skills-Verzeichnis Ihres Coding-Agenten:

```bash theme={null}
corgea skill install corgea --agent cursor --scope user
```

Unterstützte Agenten-IDs sind `cursor`, `claude-code`, `codex`, `github-copilot`, `gemini-cli`, `windsurf`, `opencode` und `universal`. Verwenden Sie `--scope project`, um in das aktuelle Repository zu installieren, `--scope user`, um für Ihr Benutzerkonto zu installieren, oder `--dir`, um in ein benutzerdefiniertes Skills-Verzeichnis zu installieren.

Hängen Sie eine bestimmte Version an den Skill-Namen an:

```bash theme={null}
corgea skill install corgea@1.0.0 --agent cursor --scope user
```

Sie können auch einen Standard-Agenten für zukünftige Installationen speichern:

```bash theme={null}
corgea skill set-default-agent cursor
corgea skill install corgea --scope user
```

#### Scan-Bericht hochladen

Laden Sie einen Scan-Bericht über STDIN oder als Datei (JSON, SARIF, FPR oder Coverity XML) zu Corgea hoch:

```bash theme={null}
corgea upload path/to/report.json
```

Um den in Corgea für hochgeladene Berichte angezeigten Projektnamen zu steuern, verwenden Sie `--project-name`. Wenn dies weggelassen wird, verwendet die CLI standardmäßig den Namen des Git-Repositorys, wenn verfügbar, und greift andernfalls auf den aktuellen Verzeichnisnamen zurück.

```bash theme={null}
corgea upload path/to/report.json --project-name my-service
```

Große Berichte lädt die CLI in Blöcken hoch. Dabei prüft sie den serverseitigen Fortschritt und beendet den Vorgang mit einem Exit-Code ungleich null, wenn der Server einen unerwarteten Offset meldet oder nach Abschluss keine Scan-ID zurückgibt.

#### Codebasis scannen

Um Ihr aktuelles Verzeichnis mit dem Standard-BLAST-Scanner zu scannen:

```bash theme={null}
corgea scan
```

Um einen anderen Scanner anzugeben, wie zum Beispiel Semgrep:

```bash theme={null}
corgea scan semgrep
```

Sie können `--fail-on` mit einer oder mehreren kommagetrennten Bedingungen verwenden: `CR`, `HI`, `ME`, `LO` oder `malicious`. Eine Schweregradbedingung erfasst Befunde dieses oder eines höheren Schweregrads. `ME` erfasst beispielsweise auch Befunde mit `HI` und `CR`. `malicious` erfasst Abhängigkeitsbefunde, die als bösartig klassifiziert wurden. Sobald eine der angegebenen Bedingungen zutrifft, endet der Befehl mit einem Exit-Code ungleich null.

Beispiele:

```bash theme={null}
corgea scan --fail-on CR
```

```bash theme={null}
corgea scan --fail-on malicious
```

```bash theme={null}
corgea scan --fail-on HI,malicious
```

Alternativ kann der Befehl anhand der in der Webanwendung definierten Blocking Rules fehlschlagen:

```bash theme={null}
corgea scan --fail
```

Standardmäßig scannt `scan` das gesamte Projekt. Um nur noch nicht committete Änderungen zu scannen, verwenden Sie `--only-uncommitted`.

```bash theme={null}
corgea scan --only-uncommitted
```

Bei BLAST-Scans können Sie mit `--target` bestimmte Dateien oder Teilbereiche Ihres Projekts auswählen. Die Option akzeptiert kommagetrennte Dateipfade, Verzeichnispfade, Glob-Muster, Git-Selektoren oder stdin.

Beispiele:

```bash theme={null}
corgea scan --target src/,pyproject.toml
```

```bash theme={null}
corgea scan --target "src/**/*.py"
```

```bash theme={null}
corgea scan --target git:diff=origin/main...HEAD
```

```bash theme={null}
corgea scan --target git:staged,git:modified,git:untracked
```

```bash theme={null}
corgea scan --target -
```

```bash theme={null}
git ls-files -z | corgea scan --target -0
```

Sie können Dateien von BLAST-Scans mit der Option `--exclude` ausschließen. Diese akzeptiert durch Kommas getrennte Glob-Muster und kann mit oder ohne `--target` verwendet werden.

```bash theme={null}
corgea scan --exclude "tests/**,**/*.test.ts"
```

```bash theme={null}
corgea scan --target "src/" --exclude "**/*.md,**/*.spec.js"
```

Hinweis: `--only-uncommitted` und `--target` können nicht zusammen verwendet werden.

Um Dateien während eines BLAST-Scans zu überspringen, verwenden Sie `--exclude` mit durch Kommas getrennten Glob-Mustern. Es kann mit `--target` kombiniert werden, um eine Teilmenge zu scannen und gleichzeitig Übereinstimmungen innerhalb dieser auszuschließen.

```bash theme={null}
corgea scan --exclude "tests/**,**/*.spec.js"
```

Um den in Corgea angezeigten Projektnamen zu steuern, verwenden Sie `--project-name`. Wenn dies weggelassen wird, verwendet die CLI standardmäßig den Namen des Git-Repositorys, falls verfügbar, und fällt auf den aktuellen Verzeichnisnamen zurück.

```bash theme={null}
corgea scan --project-name my-service
```

Um einem BLAST-Scan benutzerdefinierte Metadaten hinzuzufügen, geben Sie `--metadata` wiederholt mit `KEY=VALUE`-Paaren an. Die Werte werden dem Scan beigefügt und erscheinen in der JSON-Ausgabe der Scan-Liste.

```bash theme={null}
corgea scan --metadata pipeline_url=https://ci.example/run/123 --metadata artifact_version=1.2.3
```

`--metadata` wird nur vom BLAST-Scanner unterstützt. Jeder Eintrag muss einen nicht leeren Schlüssel haben; wenn derselbe Schlüssel mehr als einmal angegeben wird, wird der letzte Wert verwendet.

Der reguläre BLAST-Scan umfasst mehrere Scans:

* Blast Base AI Scan
* PolicyIQ Scan
* Malicious Code Detection Scan
* Secrets Detection Scan
* Erkennung von persönlich identifizierbaren Informationen (PII)

Standardmäßig werden alle diese Scans ausgeführt, sofern sie im Tarif Ihres Unternehmenskontos enthalten sind. Mit `--scan-type` können Sie den Scan auf einen oder mehrere Typen beschränken.

```bash theme={null}
corgea scan --scan-type secrets
```

oder mehrere Typen

```bash theme={null}
corgea scan --scan-type blast,malicious,policy,secrets,pii
```

Mit `--policy` beschränken Sie einen PolicyIQ-Scan auf bestimmte Richtlinien. Übergeben Sie dazu eine oder mehrere Richtlinien-IDs.

```bash theme={null}
corgea scan --scan-type policy --policy 1
```

#### Scan-Bericht exportieren

Mit der Corgea CLI können Sie Scan-Ergebnisse in eine Datei exportieren, beispielsweise bei der Ausführung in einer CI-Pipeline. Verwenden Sie dazu `--out-format` und `--out-file`.

```bash theme={null}
corgea scan --out-format=json --out-file=report.json
```

Die CLI unterstützt derzeit HTML, JSON, SARIF und Markdown als Ausgabeformate.

```bash theme={null}
corgea scan --out-format=html --out-file=report.html
```

```bash theme={null}
corgea scan --out-format=sarif --out-file=report.sarif
```

#### Abhängigkeitsinventar

Mit `corgea deps` erstellen Sie aus npm-, Python- und Java-Manifesten sowie Lockfiles ein Offline-Inventar der Abhängigkeiten. Der Befehl prüft Richtlinien zur Versionsfixierung, kann CI-Jobs anhand der Befunde fehlschlagen lassen und benötigt weder Anmeldung noch Netzwerkzugriff.

```bash theme={null}
corgea deps scan
```

Gängige Befehle für das Abhängigkeitsinventar:

```bash theme={null}
corgea deps scan --format human
corgea deps scan --format json
corgea deps scan --format quiet --fail-on high
corgea deps scan --out-format sarif --out-file deps.sarif
corgea deps graph --format json
corgea deps explain lodash --format human
corgea deps diff --base origin/main --format json
corgea deps sbom --format cyclonedx --out bom.json
corgea deps policy init --exist-ok
```

Verwenden Sie `--format human`, `agent`, `json` oder `quiet`, um die Terminalausgabe für `scan`, `graph`, `explain`, `diff` und `policy init` zu steuern. In erkannten Agent-Umgebungen verwendet `corgea deps` standardmäßig das kompakte `agent`-Format; übergeben Sie `--format human`, um die normale Terminalausgabe zu erzwingen.

Für `corgea deps scan` verwenden Sie `--out-format table`, `json` oder `sarif` mit optionalem `--out-file` beim Exportieren eines Berichts. Kombinieren Sie `--format` und `--out-format` nicht im selben `deps scan`-Befehl.

Um die Abhängigkeitsrichtlinie anzupassen, initialisieren Sie `.corgea/deps.yml`:

```bash theme={null}
corgea deps policy init
```

Die generierte Richtlinie legt fest, ob Lockfiles erforderlich sind, ob fehlende oder veraltete Lockfiles als Fehler gelten und ob direkte Abhängigkeiten mit Wildcards, `latest` oder Semver-Bereichen gemeldet werden. CI-Beispiele, Richtlinienkonfiguration und Hinweise zur Fehlerbehebung finden Sie unter [Dependency Scanning](/de/cli/deps).

#### Auf einen Scan warten

Um auf den neuesten laufenden Scan zu warten:

```bash theme={null}
corgea wait
```

Oder geben Sie eine Scan-ID an, auf die gewartet werden soll:

```bash theme={null}
corgea wait SCAN_ID
```

#### Scans, Issues oder SCA-Issues auflisten

Um alle Scans für ein aktuelles Verzeichnis aufzulisten (standardmäßig paginiert):

```bash theme={null}
corgea ls
```

So listen Sie Issues eines bestimmten Scans auf:

```bash theme={null}
corgea ls --issues --scan-id SCAN_ID
```

Sie können auch die Paginierung steuern:

```bash theme={null}
corgea list --page 1 --page-size 10
```

Hinweis: Die Option `--json` ist für Befehle wie `list` und `inspect` verfügbar, um Ergebnisse im JSON-Format auszugeben, was für Integrationen und Automatisierung nützlich ist.

```bash theme={null}
corgea list --page 1 --page-size 10 --json
```

Die Scan-Tabelle enthält die ersten acht Zeichen der Commit-SHA jedes Scans oder `N/A`, wenn keine SHA verfügbar ist. Die JSON-Ausgabe enthält den vollständigen Wert `git_sha` und alle von Corgea zurückgegebenen `metadata` des Scans.

Um SCA-Issues für ein Projekt oder einen Scan aufzulisten, verwenden Sie `--sca-issues` oder die Kurzform `-c`.

```bash theme={null}
corgea list --sca-issues --page 1 --page-size 10 --json
```

oder

```bash theme={null}
corgea list -c --page 1 --page-size 10 --json
```

#### Scan oder Issue untersuchen

Um einen bestimmten Scan zu überprüfen:

```bash theme={null}
corgea inspect SCAN_ID
```

Um Probleme mit detaillierter Ausgabe zu überprüfen:

```bash theme={null}
corgea inspect --issue --json --summary ISSUE_ID
```

Für Erläuterungen zu Fixes oder Diffs:

```bash theme={null}
corgea inspect --issue --fix ISSUE_ID
corgea inspect --issue --diff ISSUE_ID
```

### Integration mit Git-Hooks

Um Code Quality und Sicherheit zu gewährleisten, können Sie die Corgea CLI über Pre-Commit-Hooks in Ihren Git-Workflow integrieren. So scannen Sie Codeänderungen vor dem Commit oder Push. Richten Sie den Pre-Commit-Hook mit folgendem Befehl ein:

```bash theme={null}
corgea setup-hooks
```

Beim Einrichten des Pre-Commit-Hooks werden Sie nach der gewünschten Scan-Konfiguration gefragt. Die Standardkonfiguration umfasst die Scan-Typen PII und Secrets sowie die Fehlerstufen CR, HI, ME und LO. Aktivieren Sie sie mit:

```bash theme={null}
corgea setup-hooks --default-config
```

Um die Pre-Commit-Prüfung beim Commit zu umgehen, verwenden Sie den folgenden Befehl:

```bash theme={null}
git commit --no-verify
```

### Debug-Modus

Um Debug-Logs zu aktivieren, setzen Sie `CORGEA_DEBUG=1`, bevor Sie einen Befehl ausführen.

<CodeGroup>
  ```bash MacOS/Unix theme={null}
  CORGEA_DEBUG=1 corgea scan
  ```

  ```bash Windows (PowerShell) theme={null}
  $env:CORGEA_DEBUG="1"
  corgea scan
  ```
</CodeGroup>

Im Debug-Modus enthält die Debug-Ausgabe bei fehlgeschlagenen Upload-Requests den HTTP-Status und den Response Body. Dies erleichtert die Fehlerdiagnose.

### Zusätzliche Optionen

Für weitere Optionen und Befehle verwenden Sie:

```bash theme={null}
corgea --help
```

## Versionshinweise

Für vollständige Versionshinweise besuchen Sie bitte unsere [GitHub Releases-Seite](https://github.com/corgea/cli/releases).