helmpilot 0.4.2

package/README.md

@@ -0,0 +1,307 @@
+# helmpilot-channel
+
+The Helmpilot Desktop Channel plugin for OpenClaw — registers Helmpilot as a full-featured channel
+in the OpenClaw gateway, providing interactive tools, outbound messaging, and relay-based
+cross-network tunneling.
+
+**Channel ID**: `helmpilot-openclaw`
+**Config Section**: `channels.helmpilot`
+
+## Architecture
+
+Helmpilot is a desktop client that communicates with OpenClaw via WebSocket RPC.
+This plugin makes Helmpilot a **first-class channel** in the OpenClaw ecosystem,
+following the same plugin pattern as Slack, Telegram, Discord, and other channels.
+
+### Relay Tunnel
+
+When configured with a relay URL, the plugin establishes a transparent tunnel:
+
+```
+Helmpilot Desktop ──WS(deviceKey)──→ Helmpilot Relay ←──WS(channelKey)── helmpilot-channel plugin
+                                 (transparent)                         │
+                                                                  bridge WS
+                                                                       ↕
+                                                              ws://127.0.0.1:<port>
+                                                               (local gateway)
+```
+
+The relay forwards raw WebSocket messages without parsing. The plugin acts as a bridge:
+it connects to the relay as the "gateway side", then opens a local WebSocket to the
+OpenClaw gateway. Messages are transparently forwarded between these two connections.
+
+### Interactive Tool Flow
+
+```
+Agent calls hp_ask_user({ questions: [...] })
+  ↓
+OpenClaw emits tool.start event → Helmpilot client renders QuestionCard UI
+  ↓
+Plugin execute() blocks on a Promise (keyed by toolCallId)
+  ↓
+User fills answers → Helmpilot client calls helmpilot.respond via WS RPC
+  ↓
+Gateway method resolves the Promise → returns answers as tool result
+  ↓
+Agent sees actual user answers, continues reasoning
+```
+
+## Plugin Structure
+
+```
+plugins/helmpilot-channel/
+  index.ts               ← Plugin entry (definePluginEntry) — tools, RPC, channel registration
+  channel-plugin.ts      ← ChannelPlugin definition (meta/config/gateway/startAccount)
+  tools.ts               ← Tool schemas, PendingMap (Symbol.for key)
+  bridge.ts              ← LocalBridge — WS tunnel to local gateway with ping/pong heartbeat
+  outbound.ts            ← Outbound adapter (sendText/sendMedia via relay)
+  relay-client.ts        ← RelayClient with Ed25519 auth + auto-reconnect + keepalive
+  relay-registry.ts      ← Module-level Map<accountId, RelayClient> singleton
+  adapters.ts            ← Messaging/Setup/Status/Pairing/Security adapters
+  types.ts               ← Question/Answer TypeBox schemas
+  preload.cjs            ← CJS→ESM bridge + SDK symlink
+  openclaw.plugin.json   ← Manifest (declares channel: "helmpilot-openclaw")
+  package.json           ← Package metadata and OpenClaw compatibility
+  __tests__/             ← Outbound adapter + config adapter tests
+```
+
+## Channel Adapters
+
+The plugin implements the full ChannelPlugin interface:
+
+| Adapter | Source | Purpose |
+|---------|--------|---------|
+| **outbound** | `outbound.ts` | Send text/media to Helmpilot client via relay (`deliveryMode: 'direct'`, `textChunkLimit: 4000`) |
+| **messaging** | `adapters.ts` | Target normalization and resolution |
+| **setup** | `adapters.ts` | Account config validation and application |
+| **status** | `adapters.ts` | Channel summary, account snapshot, probe |
+| **pairing** | `adapters.ts` | Device key pairing (`idLabel: 'Device Key'`) |
+| **security** | `adapters.ts` | Security policy adapter |
+| **config** | Inline in plugin | Account CRUD, enable/disable, account resolution |
+
+### Outbound Adapter
+
+Sends messages as OpenClaw event frames through the relay:
+
+```typescript
+// Format sent to relay
+{
+  type: 'event',
+  event: 'helmpilot.outbound',
+  payload: {
+    kind: 'text' | 'media',
+    text?: string,
+    mediaUrl?: string,
+    messageId: string,       // Format: msg_<uuid>
+    replyToId?: string,
+    identity?: { name?, avatar?, emoji? }
+  }
+}
+```
+
+## Tools
+
+### `hp_ask_user`
+
+Present structured questions to the user in the Helmpilot desktop client.
+Blocks until the user submits answers. No fixed timeout — waits indefinitely
+until the user responds. Cleanup relies on connection/session lifecycle boundaries.
+
+```typescript
+{
+  questions: [
+    {
+      header: "Language",           // Short unique ID (max 50 chars)
+      question: "Which language?",  // Display text (max 500 chars)
+      options: [                    // Optional predefined choices
+        { label: "Python", recommended: true },
+        { label: "TypeScript" },
+        { label: "Rust", description: "Systems programming" }
+      ],
+      multiSelect: false,           // Allow multiple selections
+      allowFreeformInput: true      // Allow typing a custom answer
+    }
+  ]
+}
+```
+
+### `hp_send_msg`
+
+Send a notification or structured message to the Helmpilot client.
+Non-blocking — delivers the message for display as a distinct notification card,
+separate from inline chat stream. Supports Markdown in the message body.
+
+```typescript
+{
+  message: "Deployment **completed** successfully!",  // Markdown content
+  type: "success",        // "info" (default) | "success" | "warning" | "error"
+  title: "Deploy Status"  // Optional notification title
+}
+```
+
+### `hp_send_file`
+
+Send a file to the Helmpilot client for local display/writing.
+Non-blocking — the tool returns immediately after relaying the content.
+
+## Gateway RPC Methods
+
+### `helmpilot.respond`
+
+Called by the Helmpilot client to deliver user answers to a pending `hp_ask_user` call.
+
+```json
+{ "toolCallId": "...", "answers": "User's formatted answer string" }
+```
+
+## Configuration
+
+### CLI Quick Setup
+
+The fastest way to configure helmpilot-channel is via the OpenClaw CLI:
+
+```bash
+# Full non-interactive setup (all three fields at once)
+openclaw channels add --channel helmpilot-openclaw \
+  --url wss://relay.example.com \
+  --code helmpilot-abc123 \
+  --token ck_xyz789
+
+# Interactive wizard mode (guided step-by-step)
+openclaw channels add --channel helmpilot-openclaw
+
+# Partial update (e.g. rotate channel key only)
+openclaw channels add --channel helmpilot-openclaw --token ck_new_key
+```
+
+| CLI Flag | Config Field | Validation | Example |
+|----------|-------------|------------|---------|
+| `--url` | `channels.helmpilot.relayUrl` | Must be `ws://`, `wss://`, `http://`, or `https://` | `wss://relay.example.com` |
+| `--code` | `channels.helmpilot.channelId` | Must start with `helmpilot-` | `helmpilot-abc123` |
+| `--token` | `channels.helmpilot.channelKey` | Must start with `ck_` | `ck_xyz789` |
+
+> **Tip**: The `channelId` and `channelKey` are generated by the Relay server during
+> provisioning (triggered from the Helmpilot desktop client). Copy them from the Helmpilot
+> setup screen into the CLI command above.
+
+### Manual Configuration
+
+Add to your OpenClaw config (`openclaw.json`):
+
+### Single account (simple)
+
+```json
+{
+  "channels": {
+    "helmpilot": {
+      "enabled": true,
+      "relayUrl": "wss://relay.example.com",
+      "channelKey": "ck_xxxxx..."
+    }
+  }
+}
+```
+
+### Multi-account
+
+```json
+{
+  "channels": {
+    "helmpilot": {
+      "accounts": {
+        "work": { "relayUrl": "wss://relay.example.com", "channelKey": "ck_aaa..." },
+        "home": { "relayUrl": "wss://relay.example.com", "channelKey": "ck_bbb..." }
+      }
+    }
+  }
+}
+```
+
+### Secret storage for channelKey
+
+To avoid storing channelKey in plaintext, use any of these formats:
+
+```json
+// Env template — resolved from process.env at startup
+"channelKey": "${HELMPILOT_CHANNEL_KEY}"
+
+// SecretRef (env source)
+"channelKey": { "source": "env", "id": "HELMPILOT_CHANNEL_KEY" }
+
+// SecretRef (file source)
+"channelKey": { "source": "file", "id": "/run/secrets/helmpilot-channel-key" }
+```
+
+| Field | Type | Required | Purpose |
+|-------|------|----------|---------|
+| `enabled` | boolean | No (default: true) | Enable/disable the channel |
+| `relayUrl` | string | Yes (for relay mode) | Relay service WebSocket URL |
+| `channelId` | string | Auto-populated | Channel ID from relay registration |
+| `channelKey` | string \| SecretRef | Yes (for relay mode) | Channel key — supports env templates and SecretRef |
+
+## Installation
+
+```bash
+openclaw plugins install helmpilot-channel
+```
+
+Or add to your workspace's plugin load paths:
+
+```bash
+# Local development (symlink)
+ln -s /path/to/Helmpilot/plugins/helmpilot-channel ~/.openclaw/extensions/helmpilot-channel
+```
+
+## Relay Client
+
+`RelayClient` (`relay-client.ts`) manages the gateway-side WebSocket connection to the relay:
+
+- **Ed25519 auth**: Auto-generates key pair, handles challenge-response with relay
+- **Legacy fallback**: Falls back to `?key=<channelKey>` URL param if Ed25519 keys not registered
+- **Auto-reconnect**: Exponential backoff from 1s to 30s
+- **Keepalive**: Sends `{"__relay":true,"type":"ping"}` every 25 seconds
+- **Flush handling**: Recognizes `flush_start`/`flush_end` relay markers for buffered message batches
+- **States**: `'disconnected' | 'connecting' | 'authenticating' | 'connected' | 'error'`
+
+## Local Bridge
+
+`LocalBridge` (`bridge.ts`) manages the WS connection to the local OpenClaw gateway:
+
+- **Transparent tunnel**: Forwards raw WS frames between relay and local gateway
+- **Ping/pong heartbeat**: 20s interval + 10s timeout for dead connection detection
+- **Lifecycle**: Opened per `startAccount()`, closed on disconnect
+
+## Process Architecture
+
+The gateway loads plugin registration twice:
+- **Connection-level**: `registerGatewayMethod()` handlers (client-specific)
+- **Per-agent**: `registerTool()` handlers (agent-scoped)
+
+These scopes don't share closure variables. We use `globalThis[Symbol.for('helmpilot.pendingMap')]`
+as a process-level shared mailbox between `helmpilot.respond` (connection) and
+`hp_ask_user` execute (agent).
+
+## Multi-Account Isolation
+
+Each account gets its own `RelayClient` + `LocalBridge` pair, registered in `relay-registry.ts`.
+Outbound messages are routed to the correct relay via `getRelay(accountId)` — the null-fallback
+has been removed to prevent cross-account message leakage.
+
+The `helmpilot.respond` RPC handler requires an explicit `toolCallId` to prevent resolving
+a pending request from a different account's agent.
+
+## Testing
+
+```bash
+# All plugin tests
+npx vitest run plugins/helmpilot-channel/__tests__/
+
+# Individual test files
+npx vitest run plugins/helmpilot-channel/__tests__/outbound.test.ts       # Outbound adapter (10 cases)
+npx vitest run plugins/helmpilot-channel/__tests__/config-adapter.test.ts  # Config/multi-account (varies)
+npx vitest run plugins/helmpilot-channel/__tests__/setup-adapter.test.ts   # CLI setup adapter (16 cases)
+```
+
+## License
+
+MIT

package/__tests__/config-adapter.test.ts

@@ -0,0 +1,249 @@
+/**
+ * Tests for the helmpilot-channel plugin config adapter (multi-account support).
+ *
+ * We import the plugin definition and exercise the config.* methods
+ * to verify multi-account and legacy single-account config parsing.
+ */
+import { describe, expect, it, vi } from 'vitest';
+
+// Mock all external dependencies that the plugin imports
+vi.mock('../relay-registry.js', () => ({
+  getRelay: vi.fn(),
+  getFirstRelay: vi.fn(),
+  registerRelay: vi.fn(),
+  unregisterRelay: vi.fn(),
+}));
+vi.mock('node:crypto', () => ({ randomUUID: () => 'test-uuid' }));
+
+vi.mock('ws', () => ({
+  WebSocket: class MockWebSocket {},
+}));
+
+vi.mock('../relay-client.js', () => ({
+  RelayClient: class MockRelayClient {
+    constructor() {}
+    connect() {}
+    close() {}
+    getState() { return 'disconnected'; }
+  },
+}));
+
+vi.mock('../outbound.js', () => ({
+  createOutboundAdapter: () => ({ sendText: vi.fn(), sendMedia: vi.fn() }),
+}));
+
+vi.mock('../adapters.js', () => ({
+  createMessagingAdapter: () => ({}),
+  createSetupAdapter: () => ({}),
+  createStatusAdapter: () => ({}),
+  createPairingAdapter: () => ({}),
+  createSecurityAdapter: () => ({}),
+}));
+
+// The plugin file imports from OpenClaw SDK — mock these
+vi.mock('openclaw/plugin-sdk/plugin-entry', () => ({
+  definePluginEntry: (fn: any) => fn,
+}));
+
+vi.mock('openclaw/plugin-sdk/core', () => ({
+  ChannelPlugin: class {},
+}));
+
+vi.mock('openclaw/plugin-sdk/device-bootstrap', () => ({
+  listDevicePairing: vi.fn().mockResolvedValue({ pending: [], paired: [] }),
+  approveDevicePairing: vi.fn().mockResolvedValue(null),
+}));
+
+// Import after mocks are set up
+const pluginEntry = (await import('../index.js')).default;
+
+// The plugin registers the channel via api.registerChannel({ plugin: helmpilotPlugin })
+// We capture helmpilotPlugin by calling register() with a spy
+let helmpilotPlugin: any;
+const fakeApi = {
+  registerChannel: (opts: any) => { helmpilotPlugin = opts.plugin; },
+  registerGatewayMethod: () => {},
+  registerTool: () => {},
+  on: () => {},
+  logger: { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} },
+};
+pluginEntry.register(fakeApi);
+
+const cfg = helmpilotPlugin.config;
+
+// ── Helpers ──
+
+/** Build a full OpenClaw config shape with the given helmpilot section */
+function makeConfig(helmpilot: Record<string, unknown> = {}) {
+  return { channels: { helmpilot } };
+}
+
+describe('config adapter', () => {
+  describe('listAccountIds', () => {
+    it('returns ["default"] for empty config', () => {
+      const ids = cfg.listAccountIds({});
+      expect(ids).toEqual(['default']);
+    });
+
+    it('returns ["default"] for legacy single-account config', () => {
+      const ids = cfg.listAccountIds(
+        makeConfig({ relayUrl: 'https://relay.example.com', channelKey: 'ck_abc' }),
+      );
+      expect(ids).toEqual(['default']);
+    });
+
+    it('returns account keys from accounts object', () => {
+      const ids = cfg.listAccountIds(
+        makeConfig({
+          accounts: {
+            home: { relayUrl: 'https://r1.com', channelKey: 'ck_1' },
+            work: { relayUrl: 'https://r2.com', channelKey: 'ck_2' },
+          },
+        }),
+      );
+      expect(ids).toEqual(['home', 'work']);
+    });
+
+    it('prepends "default" when legacy top-level config coexists with accounts', () => {
+      const ids = cfg.listAccountIds(
+        makeConfig({
+          relayUrl: 'https://legacy.com',
+          channelKey: 'ck_legacy',
+          accounts: {
+            mobile: { relayUrl: 'https://r1.com', channelKey: 'ck_1' },
+          },
+        }),
+      );
+      expect(ids).toEqual(['default', 'mobile']);
+    });
+
+    it('does not duplicate default if accounts already has "default" key', () => {
+      const ids = cfg.listAccountIds(
+        makeConfig({
+          relayUrl: 'https://legacy.com',
+          channelKey: 'ck_legacy',
+          accounts: {
+            default: { relayUrl: 'https://r1.com', channelKey: 'ck_1' },
+          },
+        }),
+      );
+      expect(ids).toEqual(['default']);
+    });
+  });
+
+  describe('resolveAccount', () => {
+    it('resolves legacy single-account with top-level config', () => {
+      const account = cfg.resolveAccount(
+        makeConfig({ relayUrl: 'https://relay.example.com', channelKey: 'ck_abc' }),
+        'default',
+      );
+      expect(account.accountId).toBe('default');
+      expect(account.config.relayUrl).toBe('https://relay.example.com');
+      expect(account.config.channelKey).toBe('ck_abc');
+      expect(account.config.enabled).toBe(true);
+    });
+
+    it('resolves account from multi-account config', () => {
+      const account = cfg.resolveAccount(
+        makeConfig({
+          accounts: {
+            home: { relayUrl: 'https://r1.com', channelKey: 'ck_1' },
+            work: { relayUrl: 'https://r2.com', channelKey: 'ck_2' },
+          },
+        }),
+        'work',
+      );
+      expect(account.accountId).toBe('work');
+      expect(account.config.relayUrl).toBe('https://r2.com');
+      expect(account.config.channelKey).toBe('ck_2');
+    });
+
+    it('falls back to legacy config for unknown account ID', () => {
+      const account = cfg.resolveAccount(
+        makeConfig({ relayUrl: 'https://legacy.com', channelKey: 'ck_legacy' }),
+        'nonexistent',
+      );
+      expect(account.accountId).toBe('nonexistent');
+      expect(account.config.relayUrl).toBe('https://legacy.com');
+    });
+
+    it('defaults accountId to "default" when null', () => {
+      const account = cfg.resolveAccount(
+        makeConfig({ relayUrl: 'https://r.com', channelKey: 'ck_x' }),
+        null as any,
+      );
+      expect(account.accountId).toBe('default');
+    });
+
+    it('respects per-account enabled=false', () => {
+      const account = cfg.resolveAccount(
+        makeConfig({
+          accounts: {
+            off: { enabled: false, relayUrl: 'https://r.com', channelKey: 'ck_x' },
+          },
+        }),
+        'off',
+      );
+      expect(account.config.enabled).toBe(false);
+    });
+
+    it('respects top-level enabled=false for multi-account', () => {
+      const account = cfg.resolveAccount(
+        makeConfig({
+          enabled: false,
+          accounts: {
+            home: { relayUrl: 'https://r.com', channelId: 'helmpilot-home', channelKey: 'ck_x' },
+          },
+        }),
+        'home',
+      );
+      expect(account.config.enabled).toBe(false);
+    });
+  });
+
+  describe('isConfigured', () => {
+    it('returns true for relay config with url, channelId, and key', () => {
+      const account = cfg.resolveAccount(
+        makeConfig({ relayUrl: 'https://r.com', channelId: 'helmpilot-abc', channelKey: 'ck_x' }),
+        'default',
+      );
+      expect(cfg.isConfigured(account)).toBe(true);
+    });
+
+    it('returns false when only relayUrl is set', () => {
+      const account = cfg.resolveAccount(
+        makeConfig({ relayUrl: 'https://r.com' }),
+        'default',
+      );
+      expect(cfg.isConfigured(account)).toBe(false);
+    });
+
+    it('returns false when channelId is missing', () => {
+      const account = cfg.resolveAccount(
+        makeConfig({ relayUrl: 'https://r.com', channelKey: 'ck_x' }),
+        'default',
+      );
+      expect(cfg.isConfigured(account)).toBe(false);
+    });
+
+    it('returns true for local mode (no relay config)', () => {
+      const account = cfg.resolveAccount(makeConfig({}), 'default');
+      expect(cfg.isConfigured(account)).toBe(true);
+    });
+  });
+
+  describe('isEnabled', () => {
+    it('returns true by default', () => {
+      const account = cfg.resolveAccount(makeConfig({}), 'default');
+      expect(cfg.isEnabled(account)).toBe(true);
+    });
+
+    it('returns false when enabled is explicitly false', () => {
+      const account = cfg.resolveAccount(
+        makeConfig({ enabled: false }),
+        'default',
+      );
+      expect(cfg.isEnabled(account)).toBe(false);
+    });
+  });
+});

package/__tests__/outbound.test.ts

@@ -0,0 +1,147 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+
+// Use vi.hoisted so mock variables are available during vi.mock hoisting
+const { mockGetRelay, uuidState } = vi.hoisted(() => ({
+  mockGetRelay: vi.fn(),
+  uuidState: { counter: 0 },
+}));
+
+vi.mock('../relay-registry.js', () => ({
+  getRelay: mockGetRelay,
+}));
+
+vi.mock('node:crypto', () => ({
+  randomUUID: () => `00000000-0000-0000-0000-${String(++uuidState.counter).padStart(12, '0')}`,
+}));
+
+import { createOutboundAdapter } from '../outbound';
+
+describe('outbound adapter', () => {
+  const mockRelay = {
+    getState: vi.fn(),
+    sendRaw: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    uuidState.counter = 0;
+    mockGetRelay.mockReturnValue(mockRelay);
+    mockRelay.getState.mockReturnValue('connected');
+    mockRelay.sendRaw.mockReturnValue(true);
+  });
+
+  describe('sendText', () => {
+    it('sends text as OpenClaw event frame format', async () => {
+      const adapter = createOutboundAdapter();
+      const result = await adapter.sendText({
+        to: 'user1',
+        text: 'Hello from agent',
+      });
+
+      expect(result.channel).toBe('helmpilot');
+      expect(result.messageId).toMatch(/^msg_/);
+      expect(result.error).toBeUndefined();
+
+      const sent = JSON.parse(mockRelay.sendRaw.mock.calls[0][0]);
+      expect(sent.type).toBe('event');
+      expect(sent.event).toBe('helmpilot.outbound');
+      expect(sent.payload.kind).toBe('text');
+      expect(sent.payload.text).toBe('Hello from agent');
+      expect(sent.payload.messageId).toMatch(/^msg_/);
+    });
+
+    it('includes identity and replyToId when provided', async () => {
+      const adapter = createOutboundAdapter();
+      await adapter.sendText({
+        to: 'user1',
+        text: 'Reply',
+        replyToId: 'orig_123',
+        identity: { name: 'Bot', emoji: '🤖' },
+      });
+
+      const sent = JSON.parse(mockRelay.sendRaw.mock.calls[0][0]);
+      expect(sent.payload.replyToId).toBe('orig_123');
+      expect(sent.payload.identity).toEqual({ name: 'Bot', emoji: '🤖' });
+    });
+
+    it('returns error when relay is not connected', async () => {
+      mockRelay.getState.mockReturnValue('connecting');
+      const adapter = createOutboundAdapter();
+      const result = await adapter.sendText({ to: 'user1', text: 'Hi' });
+
+      expect(result.error).toBe('Relay not connected');
+      expect(result.messageId).toBe('');
+      expect(mockRelay.sendRaw).not.toHaveBeenCalled();
+    });
+
+    it('returns error when relay is null', async () => {
+      mockGetRelay.mockReturnValue(null);
+      const adapter = createOutboundAdapter();
+      const result = await adapter.sendText({ to: 'user1', text: 'Hi' });
+
+      expect(result.error).toBe('Relay not connected');
+    });
+
+    it('returns error when sendRaw fails', async () => {
+      mockRelay.sendRaw.mockReturnValue(false);
+      const adapter = createOutboundAdapter();
+      const result = await adapter.sendText({ to: 'user1', text: 'Hi' });
+
+      expect(result.error).toBe('Failed to send via relay');
+    });
+  });
+
+  describe('sendMedia', () => {
+    it('sends media as OpenClaw event frame format', async () => {
+      const adapter = createOutboundAdapter();
+      const result = await adapter.sendMedia({
+        to: 'user1',
+        mediaUrl: 'https://example.com/image.png',
+        text: 'Check this out',
+      });
+
+      expect(result.channel).toBe('helmpilot');
+      expect(result.error).toBeUndefined();
+
+      const sent = JSON.parse(mockRelay.sendRaw.mock.calls[0][0]);
+      expect(sent.type).toBe('event');
+      expect(sent.event).toBe('helmpilot.outbound');
+      expect(sent.payload.kind).toBe('media');
+      expect(sent.payload.mediaUrl).toBe('https://example.com/image.png');
+      expect(sent.payload.text).toBe('Check this out');
+    });
+
+    it('sends media without text', async () => {
+      const adapter = createOutboundAdapter();
+      await adapter.sendMedia({
+        to: 'user1',
+        mediaUrl: 'https://example.com/file.pdf',
+      });
+
+      const sent = JSON.parse(mockRelay.sendRaw.mock.calls[0][0]);
+      expect(sent.payload.text).toBeUndefined();
+      expect(sent.payload.mediaUrl).toBe('https://example.com/file.pdf');
+    });
+
+    it('returns error when relay is not connected', async () => {
+      mockGetRelay.mockReturnValue(null);
+      const adapter = createOutboundAdapter();
+      const result = await adapter.sendMedia({
+        to: 'user1',
+        mediaUrl: 'https://example.com/image.png',
+      });
+
+      expect(result.error).toBe('Relay not connected');
+    });
+  });
+
+  it('deliveryMode is direct', () => {
+    const adapter = createOutboundAdapter();
+    expect(adapter.deliveryMode).toBe('direct');
+  });
+
+  it('textChunkLimit is 4000', () => {
+    const adapter = createOutboundAdapter();
+    expect(adapter.textChunkLimit).toBe(4000);
+  });
+});