---
url: https://docs.ogmabox.com/pl/mcp-setup.md
description: >-
  Połącz agentów AI z Ogma przez Streamable HTTP lub stdio, skonfiguruj
  uprawnienia i korzystaj z lokalnych punktów końcowych zarządzania MCP.
---

# Konfiguracja serwera MCP Ogma {#ogma-mcp-server-setup}

Serwer MCP Ogma (`ogma-mcp`) pozwala zgodnym asystentom AI analizować kontekst projektu, a po włączeniu odpowiednich uprawnień — sterować wbudowaną przeglądarką, wysyłać żądania, uruchamiać przepływy pracy i zbierać dowody. Narzędzia notatek i zadań stanowią podręczny notatnik sesji MCP przechowywany w pamięci, odrębny od trwałej strony Notatki w aplikacji.

MCP służy narzędziom zewnętrznym, takim jak Codex, Claude Code, Cursor i inne klienty Model Context Protocol. To odrębna funkcja od asystenta AI w obszarze roboczym aplikacji.

Pełną listę zasobów i narzędzi znajdziesz na stronie [Zasoby i narzędzia MCP](./reference/mcp-tools.md).

## Szybki start: aplikacja desktopowa {#quick-start-desktop-app}

1. Uruchom Ogma i otwórz projekt, który agent ma analizować.
2. Otwórz **Ustawienia > MCP**, wybierz potrzebne uprawnienia i zapisz ustawienia. Interakcja z przeglądarką wymaga uprawnienia **Wysyłanie z panelu Ponowne wysyłanie**.
3. Kliknij **Uruchom** i skopiuj wyświetlony punkt końcowy, zwykle `http://127.0.0.1:3000/mcp`.
4. Dodaj go w kliencie MCP jako serwer **Streamable HTTP**.
5. Poproś agenta o wywołanie `ogma_explain_capabilities` i odczytanie `ogma://project/current`, aby sprawdzić połączenie i aktywny projekt.

Ten sposób nie wymaga osobnej kompilacji pliku wykonywalnego. Nawigację po stronach, formularze, scenariusze logowania i rozwiązywanie problemów opisano w [Automatyzacji przeglądarki przez MCP](./guide/mcp-browser.md).

### Adresy połączeń {#connection-addresses}

| Interfejs | Domyślny adres | Zastosowanie |
| --- | --- | --- |
| Transport MCP | `http://127.0.0.1:3000/mcp` | Tutaj łączą się natywne klienty MCP. |
| API REST backendu | `http://127.0.0.1:8181` | Adres dla `--api-url` samodzielnego MCP oraz opisanych poniżej tras zarządzania i mostu. |
| Nasłuch proxy | `127.0.0.1:8080` | Przechwytuje ruch przeglądarki; nie jest punktem końcowym MCP. |

Instancje desktopowe mogą dynamicznie przydzielać port API backendu. W integracjach stdio/REST używaj rzeczywistego adresu działającej instancji, a w natywnym MCP — punktu końcowego wyświetlanego w Ustawieniach. Usługa czatu w chmurze nie może uzyskać dostępu do adresu pętli zwrotnej bez lokalnego klienta lub konektora.

Punkt końcowy HTTP zachowuje stan: pozostaw obsługę inicjalizacji i nagłówków sesji klientowi. Nie ma osobnego, starszego punktu końcowego `/sse`. Własne klienty powinny przestrzegać [specyfikacji transportu](https://modelcontextprotocol.io/specification/2025-11-25/basic/transports) MCP.

## Kiedy korzystać z MCP {#when-to-use-mcp}

Korzystaj z MCP, gdy zewnętrzny asystent ma pomóc Ci:

* Podsumować przechwycony ruch.
* Wstępnie ocenić i uporządkować ustalenia.
* Przygotować treść raportu opartą na dowodach.
* Przejrzeć przepływy pracy i sesje ponownego wysyłania.
* Przygotować działania ograniczone do zakresu testów, które wyraźnie zatwierdzisz.

Jeśli wolisz wbudowane okno asystenta w Ogma, skorzystaj z [AI w obszarze roboczym](./guide/workspace-ai.md).

## Wymagania trybu samodzielnego {#standalone-requirements}

Użyj stdio, gdy klient musi uruchamiać lokalny plik wykonywalny zamiast łączyć się z wbudowanym punktem końcowym HTTP.

* Backend Ogma działający pod rzeczywistym adresem API (domyślnie w CLI: `http://127.0.0.1:8181`)
* Plik wykonywalny `ogma-mcp` (skompilowany ze źródeł)

## Kompilacja {#build}

```bash
cargo build --locked --bin ogma-mcp --release
```

Domyślny plik wynikowy to `target/release/ogma-mcp` (`ogma-mcp.exe` w Windows), chyba że zmieniono katalog docelowy Cargo.

## Uruchamianie {#run}

```bash
# Connect to Ogma running on the default port
./ogma-mcp

# Connect to a custom address
./ogma-mcp --api-url http://127.0.0.1:9090

# Use a larger body preview
./ogma-mcp --body-preview-bytes 2048
```

Serwer kończy działanie, jeśli nie może połączyć się z API Ogma. Skonfiguruj klienta MCP tak, aby uruchamiał to polecenie; stdout przenosi komunikaty MCP, a stderr — informacje diagnostyczne. Uprawnienia stdio wynikają z jego własnych flag, a nie z ustawień wbudowanego MCP.

## Wykrywanie narzędzi {#tool-discovery}

Obecny serwer zawsze udostępnia pełny katalog narzędzi. W Ustawieniach nie ma wyboru profilu narzędzi. Starsze wartości `--tool-profile`, `--mcp-tool-profile` i `OGMA_MCP_TOOL_PROFILE` są akceptowane dla zgodności, ale nie ukrywają narzędzi ani nie przyznają uprawnień.

Przy dużym katalogu zacznij od `ogma_explain_capabilities` i `ogma_find_tools`, zamiast zgadywać dane wejściowe. Wyszukaj słowa kluczowe zadania, aby wybrać narzędzia, a następnie wyszukaj dokładną nazwę narzędzia, aby poznać jego kontrakt. Dyspozytory przeglądarki i wyszukiwania stanowią wygodne punkty wejścia; dedykowane narzędzia nadal są dostępne bezpośrednio. Zobacz [wykrywanie narzędzi i kierowanie wywołań](./reference/mcp-tools.md#tool-discovery-and-dispatch).

## Ustawienia MCP w aplikacji {#in-app-mcp-settings}

Dystrybuowane wersje Ogma umożliwiają zarządzanie MCP w **Ustawienia > MCP**. Użyj tego ekranu, gdy Ogma ma uruchamiać lub zatrzymywać wbudowany proces MCP dla aktywnej instancji.

Użyj samodzielnego pliku wykonywalnego `ogma-mcp`, gdy klient AI oczekuje bezpośredniego uruchamiania serwera MCP.

Zapis ustawień automatycznie uruchamia ponownie działający wbudowany proces MCP. Następnie połącz klienty ponownie; starych identyfikatorów sesji i tokenów potwierdzenia nie można użyć ponownie. **Diagnostyka działania** wyświetla ostatnie komunikaty procesu.

Ogma udostępnia także zarządzanie MCP przez lokalne API REST. Te trasy znajdują się na **porcie API backendu**, a nie na dedykowanym porcie MCP. Korzystają z nich ekran ustawień i most AI w aplikacji:

| Punkt końcowy | Zastosowanie |
| --- | --- |
| `GET /mcp/status` | Zwraca `{ running, pid, endpoint, config, diagnostics }`. `endpoint` ma wartość null po zatrzymaniu; diagnostyka zawiera ostatnie rekordy `{ stream, message }`. |
| `POST /mcp/start` | Uruchamia wbudowane MCP z zapisanymi ustawieniami i zwraca stan. Bez treści żądania. Zwraca konflikt, jeśli MCP już działa. |
| `POST /mcp/stop` | Zatrzymuje proces potomny wbudowanego MCP. |
| `GET /settings/mcp` | Zwraca zapisaną konfigurację MCP. |
| `PUT /settings/mcp` | Przyjmuje kompletny obiekt konfiguracji, zapisuje go i uruchamia MCP ponownie, jeśli działa. Zwraca przyjętą konfigurację lub błąd. Dozwolone są wyłącznie adresy nasłuchu pętli zwrotnej. |
| `GET /mcp/tools` | Zwraca `{ tools, config }`, w tym `inputSchema` każdego narzędzia. Ten katalog REST nie jest stronicowany. |
| `POST /mcp/tools/call` | Wywołuje jedno narzędzie z `{ "name": "ogma_explain_capabilities", "arguments": {} }`. Zwraca `{ "result": "..." }`; sparsuj ten tekst jako otoczkę JSON wyniku narzędzia. Nie jest to natywny wynik MCP z blokami obrazów. |

Most REST korzysta z zapisanych uprawnień, ale nie wymaga uruchomienia osobnego procesu potomnego HTTP MCP. Współdzieli jedną sesję mostu dla backendu/konfiguracji. Aby korzystać z odizolowanych sesji klientów i wyników zawierających obrazy, wybierz natywne MCP.

W przypadku błędów mostu sparsowanie `result` daje `{ "error": "..." }` zawierające zserializowaną otoczkę błędu. Sprawdź tę wartość, zamiast uznawać pomyślny status HTTP za sukces narzędzia.

Domyślna zapisana konfiguracja MCP:

```json
{
  "bind_host": "127.0.0.1",
  "port": 3000,
  "allow_write_findings": false,
  "allow_export_data": false,
  "allow_read_secrets": false,
  "allow_send_requests": false,
  "allow_run_workflows": false,
  "allow_intercept_control": false,
  "tool_profile": "full"
}
```

Dozwolone adresy nasłuchu to `127.0.0.1`, `localhost` i `::1`; porty muszą mieścić się w przedziale od `1024` do `65535`. Ta kompilacja nie konfiguruje uwierzytelniania MCP dostępnego przez sieć, więc publiczne adresy nasłuchu są odrzucane. Starsze pola `allow_public_bind` i `acknowledge_write_tool_risk` nie znoszą tego ograniczenia.

## Claude Code {#claude-code}

Dla działającego punktu końcowego aplikacji desktopowej:

```bash
claude mcp add --transport http ogma http://127.0.0.1:3000/mcp
```

Jeśli Ogma wyświetla inny punkt końcowy, użyj go. Zakresy konfiguracji i opcje stdio opisano w [konfiguracji MCP w Claude Code](https://code.claude.com/docs/en/mcp). Sprawdź połączenie pytaniem: „Jakie projekty są w Ogma?”.

## Cursor {#cursor}

Dodaj ten wpis do `.cursor/mcp.json` projektu lub `~/.cursor/mcp.json` użytkownika:

```json
{
  "mcpServers": {
    "ogma": {
      "url": "http://127.0.0.1:3000/mcp"
    }
  }
}
```

Włącz połączenie w ustawieniach MCP programu Cursor. Zobacz [dokumentację MCP w Cursor](https://cursor.com/docs/mcp).

### Konfiguracja klienta stdio {#stdio-client-configuration}

Klienty uruchamiające plik wykonywalny mogą użyć tego wpisu serwera, dostosowując w razie potrzeby lokalizację pliku konfiguracji:

```json
{
  "mcpServers": {
    "ogma": {
      "command": "/absolute/path/to/ogma-mcp",
      "args": ["--api-url", "http://127.0.0.1:8181"]
    }
  }
}
```

W Windows użyj pełnej ścieżki pliku wykonywalnego i zapisz ukośniki odwrotne jako sekwencje ucieczki w JSON. Niektóre klienty wymagają też `"type": "stdio"`. W razie potrzeby dodaj flagi uprawnień do `args`.

## Uprawnienia {#permissions}

Wszystkich sześć funkcji uprzywilejowanych jest domyślnie wyłączonych. Odczytaj ich bieżące wartości z `ogma://mcp/permissions`. Narzędzie widoczne na liście może nadal odrzucać wykonanie, dopóki nie włączysz odpowiedniej funkcji. Pełna tabela flag i zmiennych środowiskowych znajduje się w [dokumentacji referencyjnej CLI](./reference/cli.md#standalone-ogma-mcp-flags).

Interakcja z przeglądarką, zarządzanie kontekstami, przełączanie projektów i wszystkie wywołania scenariuszy uwierzytelniania wymagają `--allow-send-requests`. Obserwacja przeglądarki pozwala analizować już działającą przeglądarkę bez włączania narzędzi sterujących. `--allow-read-secrets` (lub `OGMA_MCP_ALLOW_READ_SECRETS=true`) osobno zezwala na odczyt niezamaskowanych wartości zmiennych środowiskowych.

Serwer **nie ma limitów aktywności na minutę ani na sesję**. Poszczególne narzędzia nadal egzekwują limity rozmiaru danych wejściowych i partii, kontrolę zakresu testów oraz limity czasu. Stare flagi limitów wysyłania i przepływów pracy nie są już obsługiwane.

## Tryb tylko do odczytu {#read-only-mode}

Domyślnie serwer MCP działa w trybie tylko do odczytu. Następujące operacje są niedostępne, dopóki nie zostaną wyraźnie włączone:

* Wysyłanie żądań (Ponowne wysyłanie)
* Sterowanie wbudowaną przeglądarką, crawlerem, przechwytywaniem uwierzytelniania i narzędziami aktywnych sond
* Uruchamianie przepływów pracy
* Tworzenie lub modyfikowanie ustaleń
* Modyfikowanie zakresu testów lub reguł dopasowania i zamiany
* Modyfikowanie lub przekazywanie przechwyconego ruchu
* Usuwanie danych
* Dostęp do tajnych wartości zmiennych środowiskowych
* Eksport danych

Podgląd treści domyślnie obejmuje 512 bajtów. `--body-preview-bytes` dostosowuje podgląd i musi wynosić co najmniej 1; nie ogranicza wyników wszystkich narzędzi. Użyj `ogma_get_http_entry_body`, aby uzyskać pełną treść HTTP lub ukierunkowane wyszukiwanie w treści, oraz `ogma_get_ws_message`, aby uzyskać kompletną wiadomość WebSocket.

## Narzędzia zapisu ustaleń {#finding-write-tools}

Aby włączyć tworzenie ustaleń wspomagane przez AI, uruchom ponownie ogma-mcp z uprawnieniem zapisu:

```bash
./ogma-mcp --allow-write-findings
```

Lub ustaw zmienną środowiskową:

```bash
OGMA_MCP_ALLOW_WRITE_FINDINGS=true ./ogma-mcp
```

### Dostępne narzędzia zapisu {#write-tools-available}

| Narzędzie | Opis |
|------|-------------|
| `ogma_preview_finding_from_evidence` | Podgląd szkicu ustalenia na podstawie wpisu HTTP (tylko odczyt, zawsze dostępny) |
| `ogma_create_finding` | Utworzenie ustalenia z wagą, statusem, tagami i odnośnikami do dowodów |
| `ogma_update_finding` | Aktualizacja istniejącego ustalenia |
| `ogma_add_finding_tag` | Dodanie tagów do ustalenia bez zastępowania istniejących |
| `ogma_link_finding_evidence` | Powiązanie wpisu HTTP, próby ponownego wysyłania, wyniku automatyzacji lub wiadomości WS z ustaleniem |
| `ogma_delete_finding` | Usunięcie jednego ustalenia |
| `ogma_export_findings_report` | Wygenerowanie raportu HTML, Markdown lub PDF |

Obecna implementacja używa uprawnienia zapisu ustaleń także do współdzielonych narzędzi zapisu, takich jak aktualizacje zmiennych środowiskowych, adnotacje historii, wybór zakresu testów i modyfikacje Dopasowania i zamiany. Te działania opisano w [katalogu narzędzi](./reference/mcp-tools.md).

### Przykład: tworzenie ustaleń wspomagane przez AI {#example-ai-assisted-finding-creation}

Z `--allow-write-findings`:

1. „Przeanalizuj wpis HTTP {id} pod kątem problemów bezpieczeństwa. Jeśli znajdziesz rzeczywisty problem, udokumentuj go za pomocą ogma\_create\_finding”.
2. AI wywoła `ogma_get_http_entry`, aby zbadać żądanie
3. Jeśli dowody uzasadniają ustalenie, wywoła `ogma_create_finding` z powiązanymi dowodami

### Nadal niedostępne przy samym uprawnieniu zapisu ustaleń {#still-not-available-with-finding-writes-only}

* Wysyłanie z panelu Ponowne wysyłanie
* Wykonywanie przepływów pracy
* Tworzenie eksportów
* Sterowanie kolejką przechwytywania
* Przełączanie projektów

## Narzędzia eksportu {#export-tools}

Aby włączyć tworzenie zadań eksportu wspomagane przez AI, uruchom ponownie ogma-mcp z uprawnieniem eksportu:

```bash
./ogma-mcp --allow-export-data
```

Lub ustaw zmienną środowiskową:

```bash
OGMA_MCP_ALLOW_EXPORT_DATA=true ./ogma-mcp
```

### Dostępne narzędzia eksportu {#export-tools-available}

| Narzędzie | Wymagane uprawnienie | Opis |
|------|--------------------|-------------|
| `ogma_preview_export_plan` | Brak (tylko odczyt) | Podgląd danych, które znalazłyby się w eksporcie |
| `ogma_list_export_jobs` | Brak (tylko odczyt) | Lista ostatnich zadań eksportu |
| `ogma_get_export_job` | Brak (tylko odczyt) | Sprawdzenie stanu zadania eksportu |
| `ogma_get_export_download_info` | Brak (tylko odczyt) | Uzyskanie adresu URL pobierania ukończonego eksportu |
| `ogma_create_export_job` | export\_data | Utworzenie zadania eksportu |

### Obsługiwane rodzaje i formaty eksportu {#supported-export-kinds-and-formats}

| Rodzaj | Opis | Formaty |
|------|-------------|---------|
| `http_history` | Wszystkie żądania HTTP przepuszczone przez proxy | json, csv, raw\_http |
| `search` | Przefiltrowane żądania HTTP | json, csv, raw\_http |
| `findings` | Ustalenia dotyczące bezpieczeństwa | json, csv |
| `automate_results` | Wyniki sesji automatyzacji | json, csv |

Uwaga: format `raw_http` jest dozwolony wyłącznie dla rodzajów `http_history` i `search`.

### Ostrzeżenie dotyczące bezpieczeństwa {#security-warning}

Pliki eksportu mogą zawierać pełne treści żądań i odpowiedzi HTTP, w tym hasła, tokeny i dane osobowe. Obchodź się z plikami eksportu z odpowiednią ostrożnością.

### Nadal niedostępne przy samym uprawnieniu eksportu {#still-not-available-with-export-permissions-only}

* Usuwanie plików eksportu
* Zmiana nazw plików eksportu
* Strumieniowanie zawartości eksportu przez MCP
* Wysyłanie z panelu Ponowne wysyłanie
* Wykonywanie przepływów pracy

## Wysyłanie żądań w panelu Ponowne wysyłanie {#replay-request-sending}

Ostrzeżenie: to uprawnienie umożliwia wysyłanie rzeczywistego wychodzącego ruchu HTTP przez panel Ponowne wysyłanie Ogma.

Aby włączyć:

```bash
./ogma-mcp --allow-send-requests
```

Lub przez zmienne środowiskowe:

```bash
OGMA_MCP_ALLOW_SEND_REQUESTS=true ./ogma-mcp
```

### Wymagania wstępne {#prerequisites}

1. Proxy Ogma musi działać
2. W sekcji **Zakresy testów** musi być skonfigurowany aktywny zakres dla wysyłania z kontrolą zakresu w panelu Ponowne wysyłanie
3. Host docelowy musi należeć do aktywnego zakresu testów

### Narzędzia wysyłania {#send-tools}

| Narzędzie | Uprawnienie | Opis |
|------|-----------|-------------|
| `ogma_preview_replay_send` | send\_requests | Przygotowanie wysyłania i uzyskanie tokena potwierdzenia |
| `ogma_send_replay_request` | send\_requests | Wysłanie z tokenem potwierdzenia |
| `ogma_create_replay_session_from_history` | send\_requests | Utworzenie sesji ponownego wysyłania |
| `ogma_create_replay_session_raw` | send\_requests | Utworzenie sesji ponownego wysyłania z surowej definicji żądania |
| `ogma_browser_form_to_replay` | send\_requests | Utworzenie sesji ponownego wysyłania z formularza na bieżącej stronie |
| `ogma_create_scope_preset` | send\_requests | Zapisanie zestawu zakresu testów; aktywuj go osobno przez `ogma_set_active_scope` |
| `ogma_repeat_request` | send\_requests | Powtórzenie przechwyconego żądania z opcjonalnymi zmianami |
| `ogma_replay_with_modifications` | send\_requests | Ponowne wysłanie przechwyconego żądania z nadpisaniem wybranych pól |
| `ogma_http_request` | send\_requests | Wysłanie bezpośredniego żądania HTTP |
| `ogma_fetch_url` | send\_requests | Pobranie adresu URL i zwrócenie statusu, nagłówków i podglądu |
| `ogma_follow_redirect` | send\_requests | Przejście łańcucha przekierowań i opisanie każdego kroku |
| `ogma_bulk_send_requests` | send\_requests | Wysłanie partii żądań o ograniczonym rozmiarze |
| `ogma_fuzz_parameter` | send\_requests | Zastąpienie znacznika `{{FUZZ}}` wartościami z listy słów |
| `ogma_multipart_upload` | send\_requests | Wysłanie żądań multipart form-data do testowania przesyłania plików |
| `ogma_websocket_connect` | send\_requests | Połączenie z adresem URL WebSocket i wymiana wiadomości |
| `ogma_login_replay_auto` | send\_requests | Wysłanie formularza logowania w przeglądarce i przechwycenie profilu uwierzytelniania |
| `ogma_auth_capture_profile` | send\_requests | Przechwycenie ciasteczek, danych pamięci przeglądarki, tokenów uwierzytelniania i kandydatów CSRF |
| `ogma_auth_apply_profile` | send\_requests | Zastosowanie przechwyconego profilu uwierzytelniania w przeglądarce |
| `ogma_auth_refresh_csrf` | send\_requests | Odświeżenie kandydatów CSRF na podstawie stanu przeglądarki |
| `ogma_authz_matrix_test` | send\_requests | Ponowne wysłanie jednego żądania z wieloma profilami uwierzytelniania |
| `ogma_run_active_probe_workflow` | send\_requests | Uruchomienie ograniczonych aktywnych sond właściwych dla danej podatności |
| `ogma_test_race` | send\_requests | Równoczesne wysłanie jednego żądania i opisanie odpowiedzi odbiegających od najczęstszego statusu |
| `ogma_test_smuggling` | send\_requests | Wysłanie sond desynchronizacji żądań CL.TE i TE.CL przez surowe TCP |
| `ogma_test_hpp` | send\_requests | Wysłanie wariantów zanieczyszczania parametrów HTTP |
| `ogma_run_nuclei` | send\_requests | Uruchomienie jednego wbudowanego lub dostarczonego szablonu skanera szablonowego dla docelowego adresu URL |
| `ogma_browser_navigate` i narzędzia interakcji z przeglądarką | send\_requests | Sterowanie wbudowaną przeglądarką i przechwytywanie powstałego ruchu |
| `ogma_crawl_site` | send\_requests | Przeszukiwanie celu w zakresie testów przez wbudowaną przeglądarkę |
| `ogma_get_replay_session` | Brak | Wyświetlenie metadanych sesji ponownego wysyłania |
| `ogma_get_replay_attempt` | Brak | Wyświetlenie metadanych próby ponownego wysyłania |
| `ogma_list_replay_sessions` | Brak | Lista sesji ponownego wysyłania |

### Przebieg w dwóch krokach {#two-step-workflow}

Para narzędzi ponownego wysyłania wymagająca potwierdzenia używa dwóch wywołań:

1. `ogma_preview_replay_send` — przejrzyj żądanie i uzyskaj token potwierdzenia
2. `ogma_send_replay_request` — potwierdź i wyślij przy użyciu tokena

Tokeny potwierdzenia wygasają po 5 minutach, są jednorazowe i należą do sesji MCP, która je utworzyła. Po zmianie żądania lub ponownym uruchomieniu MCP wygeneruj podgląd ponownie. Ta reguła dwóch kroków nie dotyczy każdego narzędzia wysyłania: bezpośrednie narzędzia HTTP, narzędzia powtarzania i działania przeglądarki mogą wysyłać od razu po włączeniu uprawnienia.

### Przykładowa sesja {#example-session}

```
Użytkownik: Wyślij ponownie wpis HTTP abc123 i sprawdź odpowiedź
AI: (wywołuje ogma_preview_replay_send z http_entry_id="abc123")
    - pokazuje podgląd żądania, token potwierdzenia, stan zakresu testów --
AI: (wywołuje ogma_send_replay_request z confirmation_token i request_hash)
    - pokazuje status odpowiedzi, czas, podgląd odpowiedzi --
```

### Nadal niedostępne przy samym uprawnieniu wysyłania żądań {#still-not-available-with-request-sending-permissions-only}

* Wykonywanie przepływów pracy
* Tworzenie lub aktualizacja ustaleń
* Usuwanie

Przed włączeniem tych narzędzi ogranicz aktywny zakres testów. Kontrola zakresu działa w ścieżkach wysyłania, które ją egzekwują; nie traktuj zakresu jako uniwersalnej zapory dla dowolnego JavaScriptu w przeglądarce lub każdego narzędzia bezpośredniego pobierania.

## Sterowanie przechwytywaniem {#intercept-control}

Ostrzeżenie: sterowanie przechwytywaniem pozwala klientowi MCP przekazywać, odrzucać lub modyfikować bieżący ruch zatrzymany w kolejce przechwytywania Ogma.

Aby włączyć:

```bash
./ogma-mcp --allow-intercept-control
```

Lub przez zmienną środowiskową:

```bash
OGMA_MCP_ALLOW_INTERCEPT_CONTROL=true ./ogma-mcp
```

### Narzędzia przechwytywania {#intercept-tools}

| Narzędzie | Uprawnienie | Opis |
|------|-----------|-------------|
| `ogma_get_intercept_status` | intercept\_control | Odczyt stanu przechwytywania żądań, odpowiedzi i WebSocket |
| `ogma_set_intercept_enabled` | intercept\_control | Włączanie lub wyłączanie trybów przechwytywania |
| `ogma_list_intercept_queue` | intercept\_control | Lista obecnie zatrzymanych elementów |
| `ogma_get_intercept_item` | intercept\_control | Analiza jednego elementu kolejki |
| `ogma_forward_intercept_item` | intercept\_control | Przekazanie elementu kolejki z opcjonalną modyfikacją |
| `ogma_drop_intercept_item` | intercept\_control | Odrzucenie elementu kolejki |
| `ogma_intercept_and_modify` | intercept\_control | Oczekiwanie na pasujący element, zmodyfikowanie go i przekazanie |

## Wykonywanie przepływów pracy {#workflow-execution}

Ostrzeżenie: wykonywanie przepływów pracy uruchamia ich logikę. Niektóre przepływy wysyłają ruch HTTP lub tworzą ustalenia.

Aby włączyć:

```bash
./ogma-mcp --allow-run-workflows
```

### Narzędzia wykonywania przepływów pracy {#workflow-execution-tools}

| Narzędzie | Uprawnienie | Opis |
|------|-----------|-------------|
| `ogma_get_workflow_safety` | Brak (tylko odczyt) | Klasyfikacja skutków ubocznych przepływu pracy |
| `ogma_preview_workflow_run` | run\_workflows | Podgląd i uzyskanie tokena potwierdzenia |
| `ogma_run_workflow` | run\_workflows | Wykonanie z tokenem potwierdzenia |
| `ogma_cancel_workflow_run` | run\_workflows | Anulowanie działającego aktywnego przepływu pracy |

Wygeneruj podgląd z `workflow_id` oraz `input` dla przepływu konwertującego lub `trigger_entry_id` dla przechwyconych danych wejściowych aktywnego przepływu. Uruchom go ze zwróconymi `confirmation_token` i `definition_hash`; przepływy konwertujące wymagają również `input_hash` i tego samego `input`. Tokeny wygasają po pięciu minutach i są jednorazowe. Odczytaj wynikowe wykonanie za pomocą `ogma_get_workflow_run`.

Wykonywanie automatyzacji jest dostępne przez narzędzia sesji i wykonań z **uprawnieniem wysyłania żądań**, a nie uprawnieniem wykonywania przepływów pracy. Wyświetlanie listy i analiza istniejących wykonań nie wymagają uprawnienia wysyłania.

### Wymagania dodatkowych uprawnień {#cross-permission-requirements}

Przepływy pracy używające `sdk.requests.send` wymagają również `--allow-send-requests`.
Przepływy pracy używające `sdk.findings.create` wymagają również `--allow-write-findings`.

Wykrywanie opiera się na statycznej analizie tekstu — zobacz uwagę poniżej.

### Uwaga dotycząca klasyfikacji bezpieczeństwa {#safety-classification-advisory-note}

Klasyfikacja bezpieczeństwa przepływu pracy analizuje tekst źródłowy JavaScript pod kątem wzorców takich jak `sdk.requests.send`. To wykrywanie nie jest wyczerpujące — zaciemnione lub dynamicznie konstruowane wywołania metod SDK mogą pozostać niewykryte. Zawsze przejrzyj kod źródłowy JavaScript przed uruchomieniem niezaufanych przepływów pracy.

### Nadal niedostępne przy samym uprawnieniu przepływów pracy {#still-not-available-with-workflow-permissions-only}

* Ręczne wyzwalanie pasywnych przepływów pracy
* Usuwanie
* Modyfikowanie zmiennych środowiskowych

## Przykładowe polecenia dla asystenta {#example-prompts}

Po połączeniu:

* „Pokaż ostatnie 20 żądań HTTP do example.com”
* „Czy w tym projekcie są ustalenia o wysokiej lub krytycznej wadze?”
* „Które przepływy pracy są obecnie włączone?”
* „Sprawdź, czy zapytanie HTTPQL `req.method.eq:\"POST\"` jest poprawne”
* „Podsumuj stan bezpieczeństwa bieżącego projektu”
* „Przeanalizuj wpis HTTP {id} pod kątem problemów bezpieczeństwa”

## Rozwiązywanie problemów {#troubleshooting}

**Odmowa połączenia:** Najpierw uruchom Ogma (`ogma --data-dir ./ogma-data`).

**Klient MCP nie pokazuje narzędzi:** Sprawdź adres URL transportu lub ścieżkę pliku wykonywalnego. Klienty muszą obsłużyć wszystkie kursory `tools/list`; każda strona zawiera do 40 narzędzi. Sprawdź filtrowanie po stronie klienta i czy zainstalowana wersja zawiera brakujące narzędzie.

**Nieprawidłowa sesja lub token potwierdzenia:** Po ponownym uruchomieniu połącz się ponownie i wygeneruj nowy token podglądu.

**Przeglądarka niedostępna lub działanie nie powiodło się:** Pozostaw aplikację desktopową uruchomioną. Sprawdź `ogma_browser_health`, okna dialogowe i [przywracanie działania przeglądarki](./guide/mcp-browser.md#recover-from-errors). Sam backend bez interfejsu nie udostępnia mostu przeglądarki desktopowej.

**Zrzut ekranu nie zawiera czytelnego tekstu:** Użyj klienta obsługującego natywne bloki obrazów MCP lub przeanalizuj migawkę semantyczną.

**Puste wyniki:** Ogma wymaga wcześniejszego przechwycenia ruchu. Przeglądaj strony z proxy skonfigurowanym tak, aby przekazywało ruch przez Ogma.