Back to skill

Security audit

Openclaw Interaction Bridge

Security checks for vulnerabilities and agentic risk

Overview

This plugin has a coherent local display/approval purpose, but its callback security handling is too weak for an approval bridge without careful review.

Review before installing. Use this only with a trusted local Snarling service, set and protect OPENCLAW_APPROVAL_SECRET, restrict gateway logs, and avoid exposing the callback routes or changing localhost endpoints to remote hosts unless transport authentication and session binding are fixed.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (4)

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
index.ts:313
Finding

Callback-Supplied Session Keys Permit Cross-Session Targeting

Content
View full analysis

Vulnerability Details

File Location: index.ts:313-332 and index.ts:457-476
Vulnerability Type: Callback authorization and session-binding weakness
Risk Level: Medium

Vulnerable Code

Approval callback:

typescript
// Try sessionKey from body first (gateway strips query params), then URL params
const bodySessionKey = body.sessionKey;
const sessionKey = bodySessionKey || url.searchParams.get('sessionKey');
if (!sessionKey) {
  res.statusCode = 400;
  res.end(JSON.stringify({ error: "Missing sessionKey parameter" }));
  return true;
}
console.error(`[approval-callback] Using sessionKey: ${sessionKey} (from body: ${!!bodySessionKey})`);

// Bind TaskFlow to the main session for webhook context
const taskFlowApi = api.runtime?.taskFlow;
if (!taskFlowApi) {
  res.statusCode = 500;
  res.end(JSON.stringify({ error: "TaskFlow API not available", request_id }));
  return true;
}

const boundTaskFlow = taskFlowApi.bindSession({
  sessionKey,
  requesterOrigin: "snarling-webhook"
});

Notification callback:

typescript
// sessionKey from body, or fall back to URL query params
const url = new URL(req.url || '/', `http://localhost`);
const sessionKey = bodySessionKey || url.searchParams.get('sessionKey');
if (!sessionKey) {
  res.statusCode = 400;
  res.end(JSON.stringify({ error: "Missing sessionKey parameter" }));
  return true;
}
console.error(`[notification-callback] Using sessionKey: ${sessionKey} (from body: ${!!bodySessionKey})`);

// Bind TaskFlow to the session
const taskFlowApi = api.runtime?.taskFlow;
if (!taskFlowApi) {
  res.statusCode = 500;
  res.end(JSON.stringify({ error: "TaskFlow API not available", notification_id }));
  return true;
}

const boundTaskFlow = taskFlowApi.bindSession({
  sessionKey,
  requesterOrigin: "snarling-webhook"
});

Technical Analysis

The callback handlers trust a sessionKey supplied i ...[truncated 2146 chars]

Remediation
View remediation

Remediation Suggestions

  1. Store the originating sessionKey in every pending approval and notification entry.
  2. Resolve the session exclusively from the trusted pending entry:
    typescript
    const entry = pendingApprovals.get(request_id);
    if (!entry) {
      // Reject unknown or expired request.
    }
    const sessionKey = entry.sessionKey;
    
  3. Do not accept a session key from callback bodies or query parameters.
  4. If compatibility requires accepting it, compare it with the stored key and reject any mismatch.
  5. Bind each request identifier cryptographically to its session, request type, and expiration time.
  6. Use separate narrowly scoped callback credentials where practical instead of one global secret.
  7. Add tests proving that a callback cannot resume, wake, or enqueue events for a different session.

T09 · Insecure Skill Coding Practices

Warning
Location
index.ts:304
Finding

Valid Approval Secret Is Written to Logs on Authentication Failure

Content
View full analysis

Vulnerability Details

File Location: index.ts:304-310
Vulnerability Type: Sensitive credential exposure through logging
Risk Level: Medium

Vulnerable Code

typescript
// Verify approval secret from request body
const callbackSecret = secret;
if (callbackSecret !== APPROVAL_SECRET) {
  console.error(`[approval-callback] Invalid secret for request ${request_id} (got='${callbackSecret}', expected='${APPROVAL_SECRET}')`);
  res.statusCode = 403;
  res.end(JSON.stringify({ error: "Invalid or missing approval secret" }));
  return true;
}

Technical Analysis

When callback authentication fails, the handler logs both the attacker-supplied value and the valid APPROVAL_SECRET. Authentication credentials must never be included in operational logs because logs commonly have broader access, longer retention, and more downstream consumers than the process environment where the secret originated.

The logged attacker-controlled value can also contain formatting characters that pollute or forge log entries. More importantly, disclosure of the expected value directly compromises callback authentication.

Attack Path

  1. An attacker sends an approval callback with any invalid secret.
  2. The handler rejects the callback but writes the valid secret into the gateway log.
  3. The attacker or another party with log-reading access retrieves the valid secret.
  4. The attacker observes or guesses a pending request identifier.
  5. The attacker submits a forged callback with the disclosed secret.
  6. The callback is accepted and can be combined with the callback-supplied session-key weakness to target another agent session.

Impact Assessment

Any user, plugin, support process, log collector, or monitoring service that can read gateway logs may recover the reusable callback credential. Possession of this secret permits forgery of approval decisions and notification feedback when a valid pending iden ...[truncated 213 chars]

Remediation
View remediation

Remediation Suggestions

  1. Never log the received or expected secret:
    typescript
    console.error(`[approval-callback] Authentication failed for request ${request_id}`);
    
  2. Sanitize or structurally encode attacker-controlled identifiers before logging them.
  3. Rotate OPENCLAW_APPROVAL_SECRET after deploying the fix because existing logs may contain it.
  4. Restrict access to historical gateway logs and remove exposed values from retained log stores.
  5. Use a timing-safe comparison after validating that both values have the expected encoding and length.
  6. Prefer short-lived, request-specific callback tokens over a reusable global secret.
  7. Add automated tests that assert credentials never appear in captured logs.

T09 · Insecure Skill Coding Practices

Note
Location
index.ts:313
Finding

Approval Callback References an Undefined URL Variable

Content
View full analysis

Vulnerability Details

File Location: index.ts:313-315
Vulnerability Type: Callback denial of service caused by an undefined variable
Risk Level: Low

Vulnerable Code

typescript
// Try sessionKey from body first (gateway strips query params), then URL params
const bodySessionKey = body.sessionKey;
const sessionKey = bodySessionKey || url.searchParams.get('sessionKey');

The approval callback does not define url before this expression. In contrast, the notification callback explicitly creates it:

typescript
const url = new URL(req.url || '/', `http://localhost`);

Technical Analysis

JavaScript short-circuit evaluation hides the defect when body.sessionKey is truthy. If it is missing or empty, evaluation proceeds to url.searchParams, where the undeclared variable causes a ReferenceError.

Consequently, the documented query-parameter fallback cannot work reliably. The exception occurs before normal callback processing and may prevent a legitimate approval from resuming its TaskFlow.

Attack Path

  1. A callback is sent with a valid request identifier and secret but without a truthy sessionKey in its JSON body.
  2. The handler evaluates the right side of the logical OR expression.
  3. Access to the undeclared url variable throws a ReferenceError.
  4. The approval decision is not processed.
  5. The pending approval remains unavailable until stale-lock cleanup, timeout, or gateway restart.

Impact Assessment

The issue can deny approval processing for callback clients that omit the body session key or rely on the stated query-parameter fallback. It does not directly grant additional privileges, but it can interrupt workflows and keep the global single-approval lock occupied, preventing subsequent approval requests.

Remediation
View remediation

Remediation Suggestions

The preferred fix is to eliminate callback-controlled session selection and obtain the session key from the trusted pending-request record.

If URL fallback must temporarily remain, initialize the URL before use:

typescript
const url = new URL(req.url || "/", "http://localhost");
const bodySessionKey = body.sessionKey;
const sessionKey = bodySessionKey || url.searchParams.get("sessionKey");

Also:

  1. Add callback tests for missing, empty, body-based, and query-based session keys.
  2. Ensure handler exceptions are caught at the route boundary and return a controlled error.
  3. Clear or expire pending entries safely after unrecoverable callback errors.
  4. Avoid exposing raw session identifiers in URLs because URLs are frequently logged.

T09 · Insecure Skill Coding Practices

Note
Location
index.ts:120
Finding

Documented Message Length Limits Are Not Enforced

Content
View full analysis

Vulnerability Details

File Location: index.ts:120-124 and index.ts:185-190
Vulnerability Type: Missing input-size validation
Risk Level: Low

Vulnerable Code

Approval tool schema:

typescript
parameters: Type.Object({
  action: Type.String({ description: "The action requiring approval (e.g., 'delete_file', 'send_email')" }),
  message: Type.String({ description: "Human-readable message explaining what needs approval" })
}),

Notification tool schema:

typescript
parameters: Type.Object({
  message: Type.String({ description: "The notification message to display" }),
  priority: Type.Optional(Type.Union([Type.Literal("low"), Type.Literal("normal"), Type.Literal("high")], { description: "Priority level: low, normal (default), or high", default: "normal" })),
  duration: Type.Optional(Type.Number({ description: "Display duration in seconds (0 = use priority-based default: low=300s, others=no timeout)", default: 0 }))
}),

Approval data is subsequently duplicated into TaskFlow state and the HTTP request:

typescript
stateJson: {
  requestId,
  action,
  message,
  approved: null,
  respondedAt: null,
},
typescript
body: JSON.stringify({
  request_id: requestId,
  message: `${action}: ${message}`,
  secret: approvalSecret,
  sessionKey,
  timeout_seconds: 7200,
}),

Technical Analysis

The Skill documentation states that approval actions should be no more than 24 characters and messages should have an 80-character hard limit. The TypeBox schemas impose no maxLength, and the runtime functions do not enforce these limits.

Arbitrarily large strings can therefore be copied into TaskFlow state, waiting-state metadata, HTTP bodies, returned tool text, and display-service processing. This creates avoidable resource consumption and may produce unusable or misleading physical approval prompts through truncation.

Attack Path

...[truncated 988 chars]

Remediation
View remediation

Remediation Suggestions

  1. Enforce documented limits in the schemas:
    typescript
    action: Type.String({ minLength: 1, maxLength: 24 }),
    message: Type.String({ minLength: 1, maxLength: 80 })
    
  2. Define an appropriate maximum for notification messages and enforce it consistently.
  3. Validate again inside execution functions so safety does not depend solely on framework schema enforcement.
  4. Reject oversized input with a clear error rather than silently truncating approval text.
  5. Validate duration with finite minimum and maximum bounds.
  6. Add request-body limits to callback routes to prevent oversized inbound JSON payloads.
  7. Add tests for boundary lengths and very large payloads.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (32)

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
80% confidence
Finding

Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Content

Scanner excerpt · SKILL.md (reported line 41)May include surrounding context.

md
| Parameter | Type | Required | Description |
|---|---|---|---|
| `action` | string | Yes | Short verb phrase, max **24 chars** (e.g., `delete_file`, `send_email`, `publish_skill`). Shown on the display header line. |
| `message` | string | Yes | Brief explanation, max **60 chars** ideal, **80 chars** hard limit. Shown as 2 lines of ~29 chars each on the physical display. Keep it concise — long text gets truncated. (e.g., `Delete /tmp/old-logs? Cannot undo.`) |

#### When to Use

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
80% confidence
Finding

Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Content

Scanner excerpt · skills/openclaw-interaction-bridge/SKILL.md (reported line 41)May include surrounding context.

md
| Parameter | Type | Required | Description |
|---|---|---|---|
| `action` | string | Yes | Short verb phrase, max **24 chars** (e.g., `delete_file`, `send_email`, `publish_skill`). Shown on the display header line. |
| `message` | string | Yes | Brief explanation, max **60 chars** ideal, **80 chars** hard limit. Shown as 2 lines of ~29 chars each on the physical display. Keep it concise — long text gets truncated. (e.g., `Delete /tmp/old-logs? Cannot undo.`) |

#### When to Use

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
80% confidence
Finding

Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Content

Scanner excerpt · SKILL.md (reported line 87)May include surrounding context.

text
request_user_approval({
  action: "delete_important_configuration_file",  // too long for header
  message: "Delete /home/pi/old-config.yaml? This file has not been modified in 90 days and contains important settings."  // way too long
})

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
80% confidence
Finding

Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Content

Scanner excerpt · skills/openclaw-interaction-bridge/SKILL.md (reported line 87)May include surrounding context.

text
request_user_approval({
  action: "delete_important_configuration_file",  // too long for header
  message: "Delete /home/pi/old-config.yaml? This file has not been modified in 90 days and contains important settings."  // way too long
})

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
85% confidence
Finding

Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Content

Scanner excerpt · SKILL.md (reported line 202)May include surrounding context.

md
- **Notifications not showing**: Check that the plugin can reach Snarling on port 5000
- **Notification feedback not received**: Verify the gateway callback route on port 18789 is accessible; check gateway logs for `/notification-callback` hits
- **Stuck approval lock**: Wait 30 minutes for the stale timeout, or restart the gateway
- **Plugin not loading**: Check `openclaw gateway restart` logs for errors; verify `npm install` completed; clear jiti cache with `rm -f /tmp/jiti/openclaw-interaction-bridge-*.cjs`

## Install from ClawHub

Tool Parameter Abuse

High
Category
Tool Misuse
Confidence
85% confidence
Finding

Tool parameters are crafted to achieve unintended or unsafe behavior. Parameter abuse can bypass intended safety checks (e.g. shell=True, --force, dangerous glob patterns).

Content

Scanner excerpt · skills/openclaw-interaction-bridge/SKILL.md (reported line 202)May include surrounding context.

md
- **Notifications not showing**: Check that the plugin can reach Snarling on port 5000
- **Notification feedback not received**: Verify the gateway callback route on port 18789 is accessible; check gateway logs for `/notification-callback` hits
- **Stuck approval lock**: Wait 30 minutes for the stale timeout, or restart the gateway
- **Plugin not loading**: Check `openclaw gateway restart` logs for errors; verify `npm install` completed; clear jiti cache with `rm -f /tmp/jiti/openclaw-interaction-bridge-*.cjs`

## Install from ClawHub

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The README explicitly describes collecting user interaction metrics such as reveal/dismiss/timeout behavior and using them for 'notification attunement', but it does not disclose retention, consent, user visibility, or limits on downstream use. Even if the data stays local, this is a real privacy and transparency issue because the plugin influences agent behavior based on behavioral telemetry from a human user.

Content

No source excerpt is available for this finding.

Autonomous Decision Making

Medium
Category
Excessive Agency
Confidence
80% confidence
Finding

The architecture description states that Snarling can send a WebSocket RPC wake to bypass the gateway's 'requests-in-flight' check, which suggests deliberate circumvention of a built-in control intended to serialize or constrain agent actions. Bypassing control-plane safeguards can enable race conditions, unauthorized state transitions, or unintended agent execution if the external bridge or callback path is compromised.

Content

Scanner excerpt · README.md (reported line 193)May include surrounding context.

↓ (WebSocket RPC wake) ← bypasses gateway requests-in-flight

text

No approval_server middleman — the plugin talks directly to Snarling. Snarling resolves approvals and notifications via its A/B buttons and POSTs the result back to the gateway.

## Install from ClawHub

Undeclared Tool Scope

Medium
Category
MCP Least Privilege
Confidence
95% confidence
Finding

The skill declares code-plugin behavior with environment-variable and network capabilities, but does not declare any explicit tool scope such as permissions or allowed-tools. That weakens least-privilege controls and makes it harder for users or platform policy to understand and constrain what the plugin can access, especially since it exposes callback routes and posts data to external services.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
90% confidence
Finding

The skill states that notification feedback such as revealed, dismissed, timed_out, and time_to_reveal_sec is sent back to the agent for attunement, but it does not present a clear end-user privacy warning or consent model. This creates a behavioral telemetry channel that can profile user attention and response patterns without sufficiently prominent disclosure.

Content

No source excerpt is available for this finding.

External Transmission

Medium
Category
Data Exfiltration
Confidence
77% confidence
Finding

This external transmission is security-relevant because it exports approval data off the current process boundary to another service. In this skill's context, the transmitted payload includes secret and session material tied to approval control flow, which increases the risk beyond a generic outbound request.

Content

Scanner excerpt · approval_tool.ts (reported line 197)May include surrounding context.

ts
// Notify snarling display directly (port 5000) - no middleman
  // Include sessionKey so snarling can pass it back in the callback URL
  try {
    await fetch("http://localhost:5000/approval/alert", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The code sends approval metadata, a shared secret, and a session key over plain HTTP to localhost. Even though the destination is loopback, any local malicious process, container sidecar, proxy, or compromised host component that can observe or bind that port can intercept or abuse these values to spoof approval callbacks or hijack session-scoped actions.

Content

No source excerpt is available for this finding.

Internal Network Request

Medium
Category
Server-Side Request Forgery
Confidence
70% confidence
Finding

Code issues a request to a loopback, link-local, or private-range host. This can reach internal services not meant to be exposed and is a common SSRF pivot.

Content

Scanner excerpt · approval_tool.ts (reported line 197)May include surrounding context.

ts
// Notify snarling display directly (port 5000) - no middleman
  // Include sessionKey so snarling can pass it back in the callback URL
  try {
    await fetch("http://localhost:5000/approval/alert", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({

Internal Network Request

Medium
Category
Server-Side Request Forgery
Confidence
70% confidence
Finding

Code issues a request to a loopback, link-local, or private-range host. This can reach internal services not meant to be exposed and is a common SSRF pivot.

Content

Scanner excerpt · approval_tool.ts (reported line 404)May include surrounding context.

ts
// Notify snarling display directly (port 5000) - no middleman
  // Include sessionKey so snarling can pass it back in the callback URL
  try {
    await fetch("http://localhost:5000/approval/alert", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({

Internal Network Request

Medium
Category
Server-Side Request Forgery
Confidence
70% confidence
Finding

Code issues a request to a loopback, link-local, or private-range host. This can reach internal services not meant to be exposed and is a common SSRF pivot.

Content

Scanner excerpt · index.ts (reported line 232)May include surrounding context.

ts
// Notify snarling display directly (port 5000) - no middleman
  // Include sessionKey so snarling can pass it back in the callback URL
  try {
    await fetch("http://localhost:5000/approval/alert", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({

External Transmission

Medium
Category
Data Exfiltration
Confidence
80% confidence
Finding

This outbound transmission is not inherently dangerous in isolation, but here it carries callback and session information to another process. Because this bridge directly affects agent feedback loops and event injection, compromise of the receiving service or interception of the data can enable manipulation of agent-visible state.

Content

Scanner excerpt · approval_tool.ts (reported line 404)May include surrounding context.

ts
// Notify snarling display directly (port 5000)
  try {
    await fetch("http://localhost:5000/approval/alert", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
96% confidence
Finding

Notification delivery includes sensitive callback and session data over plain HTTP to a local service. In the context of an interaction bridge that can wake agent sessions and feed back events, exposure of callback/session material can let a local attacker forge notification feedback, influence agent behavior, or pivot into unauthorized session interaction.

Content

No source excerpt is available for this finding.

Description-Behavior Mismatch

Medium
Category
Not specified by scanner
Confidence
95% confidence
Finding

The declared plugin description is limited to sending agent state to the snarling display via HTTP. In addition to that expected behavior, the code registers tools and HTTP endpoints that accept approval/notification feedback and invoke resumeApprovalFlow/resumeNotificationFlow plus heartbeat wake-ups, which is materially broader than simple state bridging.

Content

No source excerpt is available for this finding.

External Transmission

Medium
Category
Data Exfiltration
Confidence
60% confidence
Finding

Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Content

Scanner excerpt · index.ts (reported line 232)May include surrounding context.

ts
// Fallback: fire-and-forget notification (no feedback)
          try {
            const response = await fetch("http://localhost:5000/approval/alert", {
              method: "POST",
              headers: { "Content-Type": "application/json" },
              body: JSON.stringify({

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
96% confidence
Finding

On authentication failure, the code logs both the provided secret and the expected secret, exposing the live shared secret to anyone with log access. Because that same secret authorizes approval and notification callbacks that resume TaskFlows and wake agent sessions, log disclosure can become a privilege-bypass path.

Content

No source excerpt is available for this finding.

Missing User Warnings

Medium
Category
Not specified by scanner
Confidence
93% confidence
Finding

The README explicitly describes sending agent state, approvals, and notification data to an external companion service, but it does not prominently warn users about the privacy and observability implications of exposing agent activity to another process/device. Even though the example target is localhost/Raspberry Pi, the skill increases external visibility into agent behavior and user interactions, which can leak sensitive operational context if deployed beyond a trusted local setup.

Content

No source excerpt is available for this finding.

Autonomous Decision Making

Medium
Category
Excessive Agency
Confidence
80% confidence
Finding

Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Content

Scanner excerpt · README.md (reported line 7)May include surrounding context.

md
## What It Does

- **State display**: Automatically sends agent state changes (processing, communicating, sleeping) to Snarling's display
- **Physical approvals**: Registers a `request_user_approval` tool that routes yes/no decisions to Snarling's A/B buttons
- **Notifications**: Registers a `send_notification` tool that sends alerts to the display with priority-based timeouts and full two-way feedback
- **Notification feedback**: Receives callback data from Snarling (revealed, dismissed, timed out) with timing metrics, enabling notification attunement

Autonomous Decision Making

Medium
Category
Excessive Agency
Confidence
80% confidence
Finding

Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Content

Scanner excerpt · skills/openclaw-interaction-bridge/README.md (reported line 7)May include surrounding context.

md
## What It Does

- **State display**: Automatically sends agent state changes (processing, communicating, sleeping) to Snarling's display
- **Physical approvals**: Registers a `request_user_approval` tool that routes yes/no decisions to Snarling's A/B buttons
- **Notifications**: Registers a `send_notification` tool that sends alerts to the display with priority-based timeouts and full two-way feedback
- **Notification feedback**: Receives callback data from Snarling (revealed, dismissed, timed out) with timing metrics, enabling notification attunement

External Transmission

Medium
Category
Data Exfiltration
Confidence
60% confidence
Finding

Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Content

Scanner excerpt · README.md (reported line 168)May include surrounding context.

Query the stats:

bash
curl -s -X POST http://localhost:18789/approval-callback \
  -H "Authorization: Bearer <gateway-token>" \
  -H "Content-Type: application/json" \
  -d '{"action":"stats"}'

External Transmission

Medium
Category
Data Exfiltration
Confidence
60% confidence
Finding

Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Content

Scanner excerpt · skills/openclaw-interaction-bridge/README.md (reported line 168)May include surrounding context.

Query the stats:

bash
curl -s -X POST http://localhost:18789/approval-callback \
  -H "Authorization: Bearer <gateway-token>" \
  -H "Content-Type: application/json" \
  -d '{"action":"stats"}'