plumb-bridge 0.1.2 → 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kariem Seiam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,193 @@
+```
+   ____  _                 _
+  |  _ \| |_   _ _ __ ___ | |__
+  | |_) | | | | | '_ ` _ \| '_ \
+  |  __/| | |_| | | | | | | |_) |
+  |_|   |_|\__,_|_| |_| |_|_.__/
+```
+
+**Quiet pipes for noisy agents.**
+
+[![CI](https://github.com/kariemSeiam/plumb/actions/workflows/ci.yml/badge.svg)](https://github.com/kariemSeiam/plumb/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/plumb-bridge)](https://www.npmjs.com/package/plumb-bridge)
+[![License: MIT](https://img.shields.io/badge/License-MIT-brass.svg)](./LICENSE)
+
+---
+
+Plumb wraps any CLI coding agent into an [A2A](https://google.github.io/A2A/)-compliant HTTP server in one command.
+
+```
+Orchestrator → HTTP/JSON-RPC → Plumb → stdin/stdout → CLI agent → stream parse → A2A events
+```
+
+## Install
+
+```bash
+bun add -g plumb-bridge
+```
+
+Requires [Bun](https://bun.sh) >= 1.1.0.
+
+## Quick Start
+
+```bash
+# Wrap any CLI as an A2A agent
+plumb wrap cat --port 3001              # Echo (conformance gate)
+plumb wrap "pi --mode rpc" --port 3002 # Pi (persistent JSONL-RPC)
+plumb wrap claude --port 3000           # Claude Code (stream-json)
+plumb wrap cursor-agent --port 3003     # Cursor (stream-json)
+plumb wrap opencode --port 3002         # OpenCode (json-stream)
+plumb wrap venom --port 3004            # VENOM (stream-json)
+plumb wrap wolfy --port 3007            # Wolfy (persistent, PI_CODING_AGENT_DIR)
+plumb wrap "./my-tool" --port 3005      # Generic (any CLI)
+```
+
+Once running:
+
+```bash
+# Agent Card (public, unauthenticated)
+curl http://localhost:3001/.well-known/agent-card.json
+
+# Health check
+curl http://localhost:3001/health
+
+# Send a task via JSON-RPC
+curl -X POST http://localhost:3001/a2a/jsonrpc \
+  -H "Content-Type: application/json" \
+  -d '{
+    "jsonrpc": "2.0",
+    "method": "message/send",
+    "params": {
+      "message": {
+        "messageId": "msg-001",
+        "role": "user",
+        "parts": [{ "kind": "text", "text": "Hello from Plumb" }]
+      }
+    },
+    "id": "req-1"
+  }'
+```
+
+## Fleet Mode
+
+Define multiple agents in `plumb.yaml`:
+
+```yaml
+version: "1"
+agents:
+  - id: pi
+    cli: pi
+    port: 3001
+    mode: persistent
+  - id: claude
+    cli: claude
+    port: 3002
+  - id: cursor
+    cli: cursor-agent --print
+    port: 3003
+```
+
+```bash
+plumb fleet validate          # Check config
+plumb fleet up                # Boot all agents
+plumb fleet status            # Health check all
+```
+
+## Adapters
+
+| Adapter   | CLI             | Mode       | Tier | Protocol     |
+|-----------|-----------------|------------|------|--------------|
+| Echo      | `cat`           | oneshot    | 1    | text         |
+| Pi        | `pi`            | persistent | 1    | jsonl-rpc    |
+| Wolfy 🐺  | `wolfy`         | persistent | 1    | jsonl-rpc    |
+| Claude    | `claude`        | oneshot    | 1    | stream-json  |
+| Cursor    | `cursor-agent`  | oneshot    | 1    | stream-json  |
+| OpenCode  | `opencode`      | oneshot    | 2    | json-stream  |
+| VENOM     | `venom`         | oneshot    | 3    | stream-json  |
+| Generic   | any             | oneshot    | 3    | text         |
+
+Adapters implement one interface: `buildArgs`, `formatInput`, `parseLine`, `detect`. Registry matches by binary name. Generic is the implicit fallback.
+
+## Auth
+
+```bash
+plumb wrap claude --port 3003 --key my-secret-token
+```
+
+When `--key` is set, `/a2a/*` endpoints require `Authorization: Bearer <key>`. Agent Card and health remain public per A2A spec.
+
+## Ledger
+
+Every task lifecycle event is appended to `.plumb/ledger/{YYYY-MM-DD}.jsonl`:
+
+```jsonl
+{"type":"task_submitted","taskId":"abc","cli":"cat","message":"hello","timestamp":"..."}
+{"type":"task_running","taskId":"abc","timestamp":"..."}
+{"type":"progress","taskId":"abc","text":"hello\n","timestamp":"..."}
+{"type":"task_completed","taskId":"abc","timestamp":"..."}
+```
+
+Append-only. Never modified. Query with `jq`. Crash-survivable.
+
+```bash
+# Failed tasks today
+jq 'select(.type=="task_failed") | {taskId, error}' \
+  .plumb/ledger/$(date +%Y-%m-%d).jsonl
+
+# Reconstruct output for a task
+jq -r 'select(.type=="progress" and .taskId=="<id>") | .text' \
+  .plumb/ledger/$(date +%Y-%m-%d).jsonl
+```
+
+## Architecture
+
+```
+src/
+  types.ts           Core interfaces (AgentTask, AdapterEvent, AgentAdapter, LedgerEvent)
+  cli.ts             CLI: plumb wrap <cli> --port <n>, fleet commands
+  main.ts            Entry point
+  adapters/
+    stream-json.ts   Shared parseLine utilities
+    echo.ts          EchoAdapter (cat) — conformance gate
+    pi.ts            PiAdapter — persistent JSONL-RPC
+    claude.ts        ClaudeAdapter — stream-json
+    cursor.ts        CursorAdapter — stream-json + session tracking
+    opencode.ts      OpenCodeAdapter — json-stream
+    venom.ts         VenomAdapter — stream-json
+    wolfy.ts         WolfyAdapter — persistent JSONL-RPC, PI_CODING_AGENT_DIR
+    generic.ts       GenericAdapter — text passthrough
+    registry.ts      detectAdapter() — binary matching
+  core/
+    ledger.ts        Append-only JSONL
+    process.ts       ProcessManager + PersistentProcess
+    executor.ts      PlumbExecutor (A2A AgentExecutor)
+    server.ts        Express + @a2a-js/sdk
+    task-store.ts    LRU + TTL bounded task store
+    session-store.ts Cursor multi-turn session tracking
+```
+
+## Development
+
+```bash
+bun install                    # Install dependencies
+bun test                       # Run all tests (90 tests)
+bun run typecheck              # TypeScript type checking
+bun run src/main.ts wrap cat --port 3001  # Run locally
+```
+
+## Protocol Surface
+
+| Method | Path | Auth |
+|--------|------|------|
+| GET | `/.well-known/agent-card.json` | public |
+| GET | `/health` | public |
+| POST | `/a2a/jsonrpc` | Bearer (if configured) |
+| * | `/a2a/rest` | Bearer (if configured) |
+
+## License
+
+[MIT](./LICENSE)
+
+---
+
+*The plumb bob hangs true because gravity is not negotiable. The protocol gap is not negotiable either.*

package/package.json

@@ -1,7 +1,17 @@
 {
   "name": "plumb-bridge",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "A2A bridge for CLI coding agents. Bun runtime. Example: plumb wrap cat --port 3001. Use plumb wrap opencode (not opencode run — the adapter adds run --format json).",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kariemSeiam/plumb.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kariemSeiam/plumb/issues"
+  },
+  "homepage": "https://github.com/kariemSeiam/plumb#readme",
+  "author": "Kariem Seiam <kariemSeiam@users.noreply.github.com>",
+  "license": "MIT",
   "type": "module",
   "module": "src/main.ts",
   "bin": {
@@ -12,7 +22,9 @@
     "src",
     "test",
     "tsconfig.json",
-    "bunfig.toml"
+    "bunfig.toml",
+    "README.md",
+    "LICENSE"
   ],
   "engines": {
     "bun": ">=1.1.0"
@@ -28,11 +40,13 @@
   "dependencies": {
     "@a2a-js/sdk": "^0.3.13",
     "commander": "^14.0.3",
-    "express": "^5.2.1"
+    "express": "^5.2.1",
+    "js-yaml": "^4.1.1"
   },
   "devDependencies": {
     "@types/bun": "latest",
     "@types/express": "^5.0.6",
+    "@types/js-yaml": "^4.0.9",
     "typescript": "^5"
   },
   "peerDependencies": {

package/src/adapters/claude.ts

@@ -1,24 +1,14 @@
 // PLUMB — Claude Adapter
 // Wraps `claude --print --output-format stream-json --verbose`. Streaming JSONL.
 // Filters system/rate-limit events. Captures assistant messages and results.
+// Uses shared stream-json parser for content extraction.
 
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import type { AgentAdapter, AgentTask, AdapterEvent, DetectionResult, PlumbConfig } from '../types.ts';
-
-const execFileAsync = promisify(execFile);
-
-interface ClaudeStreamEvent {
-  type: string;
-  subtype?: string;
-  message?: {
-    content?: Array<{ type: string; text?: string }>;
-  };
-  result?: string;
-  is_error?: boolean;
-  error?: string;
-  [key: string]: unknown;
-}
+import { tryParseLine, extractContentText, textDelta, statusEvent, errorEvent } from './stream-json.ts';
+import type { ContentBlockEvent } from './stream-json.ts';
+import { detectBinary } from './detect.ts';
 
 export class ClaudeAdapter implements AgentAdapter {
   readonly id = 'claude';
@@ -43,67 +33,36 @@ export class ClaudeAdapter implements AgentAdapter {
   }
 
   parseLine(line: string): AdapterEvent[] {
-    if (!line.trim()) return [];
-
-    let event: ClaudeStreamEvent;
-    try {
-      event = JSON.parse(line);
-    } catch {
-      // Non-JSON line — treat as raw text
-      return [{ type: 'text-delta', text: line + '\n' }];
+    const { json, raw } = tryParseLine(line);
+    if (!json) {
+      if (!raw) return [];
+      return [textDelta(raw + '\n')];
     }
 
     // Filter non-content events
-    if (event.type === 'rate_limit_event') return [];
-    if (event.type === 'system') return [];
+    if (json.type === 'rate_limit_event' || json.type === 'system') return [];
 
     // Assistant message — extract text content
-    if (event.type === 'assistant' && event.message?.content) {
-      const texts = event.message.content
-        .filter(c => c.type === 'text' && c.text)
-        .map(c => c.text!);
-      if (texts.length > 0) {
-        return [{ type: 'text-delta', text: texts.join('\n') }];
-      }
-      return [];
+    if (json.type === 'assistant') {
+      const extracted = extractContentText(json as ContentBlockEvent);
+      return extracted ? [textDelta(extracted)] : [];
     }
 
-    // Result event — final output
-    if (event.type === 'result') {
-      if (event.is_error || event.error) {
-        return [{ type: 'error', message: event.error ?? 'Unknown error' }];
+    if (json.type === 'result') {
+      if (json.is_error || json.error) {
+        return [errorEvent(json.error ?? 'Unknown error')];
       }
-      // Result text is already captured from assistant message, signal completion
-      return [{ type: 'status', state: 'completed' }];
+      return [statusEvent('completed')];
     }
 
-    // Error event
-    if (event.type === 'error') {
-      return [{ type: 'error', message: String(event.error ?? event.message ?? 'Unknown error') }];
+    if (json.type === 'error') {
+      return [errorEvent(String(json.error ?? json.message ?? 'Unknown error'))];
     }
 
     return [];
   }
 
-  async detect(): Promise<DetectionResult | null> {
-    try {
-      const { stdout } = await execFileAsync('which', ['claude'], { timeout: 5000 });
-      let version = 'unknown';
-      try {
-        const { stdout: vOut } = await execFileAsync('claude', ['--version'], { timeout: 5000 });
-        version = vOut.trim().split('\n')[0] ?? 'unknown';
-      } catch {
-        // Version check failed
-      }
-      return {
-        binary: 'claude',
-        version,
-        path: stdout.trim(),
-        tier: 1,
-        protocol: 'stream-json',
-      };
-    } catch {
-      return null;
-    }
+  detect(): Promise<DetectionResult | null> {
+    return detectBinary('claude', 1, 'stream-json');
   }
-}
+}

package/src/adapters/cursor.ts

@@ -0,0 +1,213 @@
+// PLUMB — Cursor Adapter
+// Wraps `cursor-agent --print --output-format stream-json`.
+// Multi-turn session tracking with --continue / cold recap.
+
+import type { AgentAdapter, AgentTask, AdapterEvent, DetectionResult, PlumbConfig } from '../types.ts';
+import { CursorSessionStore } from '../core/session-store.ts';
+import { tryParseLine, extractContentText, isConsolidatedAssistant, textDelta, statusEvent, errorEvent } from './stream-json.ts';
+import type { ContentBlockEvent } from './stream-json.ts';
+import { detectBinary } from './detect.ts';
+
+export interface CursorAdapterOptions {
+  defaultModel?: string;
+  streamPartial?: boolean;
+  yolo?: boolean;
+  trust?: boolean;
+  maxSessionTurns?: number;
+  sessionStore?: CursorSessionStore;
+  sessionTtlMs?: number | null;
+  recapMaxTurns?: number;
+  recapMaxCharsPerLeg?: number;
+}
+
+export class CursorAdapter implements AgentAdapter {
+  readonly id = 'cursor';
+  readonly binary = 'cursor-agent';
+  readonly tier = 1 as const;
+  readonly displayName = 'Cursor';
+  readonly mode = 'oneshot' as const;
+
+  streamPartial: boolean;
+  readonly yolo: boolean;
+  readonly trust: boolean;
+  readonly maxSessionTurns: number;
+  readonly defaultModel: string;
+
+  // Model routing table — VENOM routes by task label → best model per job
+  readonly modelMap: Record<string, string> = {
+    build: 'gpt-5.3-codex-high-fast',
+    implement: 'gpt-5.3-codex-high-fast',
+    research: 'claude-opus-4-7-thinking-high',
+    deep: 'claude-opus-4-7-max-thinking-fast',
+    review: 'claude-4.5-opus-high',
+    audit: 'claude-opus-4-7-high',
+    fast: 'composer-2.5-fast',
+    default: 'composer-2.5-fast',
+    nano: 'gpt-5.4-nano-high',
+    plan: 'composer-2.5',
+    ask: 'composer-2.5-fast',
+  };
+
+  readonly sessionStore: CursorSessionStore;
+
+  private taskAssistantForRecap = '';
+  private lastUserMessage = '';
+
+  skills = [
+    { id: 'code', name: 'Code generation and editing', tags: ['code', 'edit', 'write', 'composer'] },
+    { id: 'bash', name: 'Execute shell commands', tags: ['bash', 'shell', 'terminal'] },
+    { id: 'read', name: 'Read files', tags: ['read', 'file'] },
+    { id: 'plan', name: 'Plan mode', tags: ['plan', 'architecture'] },
+  ];
+
+  constructor(opts: CursorAdapterOptions = {}) {
+    this.streamPartial = opts.streamPartial ?? false;
+    this.yolo = opts.yolo ?? true;
+    this.trust = opts.trust ?? true;
+    this.maxSessionTurns = opts.maxSessionTurns ?? 50;
+    this.defaultModel = opts.defaultModel ?? 'composer-2.5-fast';
+    this.sessionStore = opts.sessionStore ?? new CursorSessionStore({
+      sessionTtlMs: opts.sessionTtlMs,
+      recapMaxTurns: opts.recapMaxTurns,
+      recapMaxCharsPerLeg: opts.recapMaxCharsPerLeg,
+    });
+  }
+
+  buildArgs(task: AgentTask, config: PlumbConfig): string[] {
+    const args: string[] = ['--print', '--output-format', 'stream-json'];
+
+    if (this.streamPartial) args.push('--stream-partial-output');
+    if (this.yolo) args.push('--yolo');
+    if (this.trust) args.push('--trust');
+
+    // Route by task label → best model for job, else default
+    const labels = (task.context?.labels as string[]) ?? [];
+    let selectedModel = this.defaultModel;
+    for (const label of labels) {
+      if (this.modelMap[label]) {
+        selectedModel = this.modelMap[label];
+        break;
+      }
+    }
+    // Explicit model override wins
+    const model = (task.context?.metadata?.model as string) ?? selectedModel;
+    args.push('--model', model);
+
+    const workspace = task.context?.workdir ?? config.workdir;
+    if (workspace) args.push('--workspace', workspace);
+
+    const apiKey = process.env.CURSOR_API_KEY;
+    if (apiKey) args.push('--api-key', apiKey);
+
+    this.sessionStore.expireLastSessionIfStale();
+
+    const resumeSession = task.context?.metadata?.resumeSession as string | undefined;
+    const continueLast = task.context?.metadata?.continueLast as boolean | undefined;
+    const newChat = task.context?.metadata?.newChat as boolean | undefined;
+
+    if (resumeSession) {
+      args.push('--resume', resumeSession);
+    } else if (continueLast && this.sessionStore.lastSession) {
+      args.push('--continue');
+    } else if (!newChat && this.sessionStore.lastSession) {
+      const session = this.sessionStore.get(this.sessionStore.lastSession);
+      if (session && session.turnCount < this.maxSessionTurns) {
+        args.push('--continue');
+      }
+    }
+
+    if (task.context?.metadata?.planMode) {
+      args.push('--plan');
+    }
+
+    return args;
+  }
+
+  formatInput(task: AgentTask): string {
+    this.taskAssistantForRecap = '';
+    const newChat = task.context?.metadata?.newChat === true;
+    let recap: string | null = null;
+    if (newChat) {
+      this.sessionStore.consumeColdRecap();
+    } else {
+      recap = this.sessionStore.consumeColdRecap();
+    }
+    const body = `${task.message}\n`;
+    return recap ? `${recap}${body}` : body;
+  }
+
+  parseLine(line: string): AdapterEvent[] {
+    const { json, raw } = tryParseLine(line);
+    if (!json) {
+      if (!raw) return [];
+      return [textDelta(raw + '\n')];
+    }
+
+    if (json.type === 'system') {
+      if (typeof json.session_id === 'string') {
+        this.sessionStore.register(
+          json.session_id,
+          typeof json.cwd === 'string' ? json.cwd : '',
+          typeof json.model === 'string' ? json.model : '',
+        );
+      }
+      return [];
+    }
+
+    if (json.type === 'user') return [];
+
+    if (json.type === 'thinking' && typeof (json as Record<string, unknown>).text === 'string') {
+      return [textDelta((json as Record<string, unknown>).text as string)];
+    }
+
+    if (json.type === 'assistant') {
+      const contentEvent = json as ContentBlockEvent;
+      if (isConsolidatedAssistant(contentEvent, this.streamPartial)) return [];
+      const extracted = extractContentText(contentEvent);
+      if (extracted) this.taskAssistantForRecap += extracted;
+      return extracted ? [textDelta(extracted)] : [];
+    }
+
+    if (json.type === 'tool_call') {
+      const tc = (json as Record<string, unknown>).tool_call as { shellToolCall?: { args?: Record<string, unknown>; result?: string } } | undefined;
+      if (tc?.shellToolCall) {
+        return [{ type: 'tool-call', tool: 'shell', input: tc.shellToolCall.args ?? {} }];
+      }
+      return [];
+    }
+
+    if (json.type === 'result') {
+      if (json.subtype === 'error' || json.is_error) {
+        this.resetRecapTaskState();
+        return [errorEvent(String(json.error ?? 'Cursor execution failed'))];
+      }
+
+      this.sessionStore.recordCompletedTurn(
+        this.sessionStore.lastSession,
+        this.lastUserMessage,
+        this.taskAssistantForRecap,
+      );
+      this.resetRecapTaskState();
+      return [statusEvent('completed')];
+    }
+
+    if (json.type === 'error') {
+      this.resetRecapTaskState();
+      return [errorEvent(String(json.error ?? json.message ?? 'Unknown error'))];
+    }
+
+    return [];
+  }
+
+  detect(): Promise<DetectionResult | null> {
+    return detectBinary('cursor-agent', 1, 'stream-json');
+  }
+
+  setUserMessage(msg: string): void {
+    this.lastUserMessage = msg;
+  }
+
+  private resetRecapTaskState(): void {
+    this.taskAssistantForRecap = '';
+  }
+}

package/src/adapters/detect.ts

@@ -0,0 +1,27 @@
+// PLUMB — Shared binary detection utility
+// All adapters use the same `which` + `--version` pattern. DRY it.
+
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import type { DetectionResult } from '../types.ts';
+
+const execFileAsync = promisify(execFile);
+
+export async function detectBinary(
+  name: string,
+  tier: 1 | 2 | 3,
+  protocol: string,
+  versionArgs: string[] = ['--version'],
+): Promise<DetectionResult | null> {
+  try {
+    const { stdout } = await execFileAsync('which', [name], { timeout: 5000 });
+    let version = 'unknown';
+    try {
+      const { stdout: vOut } = await execFileAsync(name, versionArgs, { timeout: 5000 });
+      version = vOut.trim().split('\n')[0] ?? 'unknown';
+    } catch { /* version check failed */ }
+    return { binary: name, version, path: stdout.trim(), tier, protocol };
+  } catch {
+    return null;
+  }
+}

package/src/adapters/echo.ts

@@ -1,13 +1,8 @@
 // PLUMB — Echo Adapter
-// Wraps `cat`. Proves the bridge works. Emits a real A2A task lifecycle.
-// Every line cat echoes becomes a progress event. Exit 0 → completed.
-// Stolen from fangai's Echo First pattern, implemented as a real CLI wrapper.
+// Wraps `cat`. Proves the bridge works. Every line becomes a progress event.
 
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
 import type { AgentAdapter, AgentTask, AdapterEvent, DetectionResult, PlumbConfig } from '../types.ts';
-
-const execFileAsync = promisify(execFile);
+import { detectBinary } from './detect.ts';
 
 export class EchoAdapter implements AgentAdapter {
   readonly id = 'echo';
@@ -20,9 +15,7 @@ export class EchoAdapter implements AgentAdapter {
     { id: 'echo', name: 'Echo task input', tags: ['echo', 'test', 'conformance'] },
   ];
 
-  buildArgs(_task: AgentTask, _config: PlumbConfig): string[] {
-    return [];
-  }
+  buildArgs(_task: AgentTask, _config: PlumbConfig): string[] { return []; }
 
   formatInput(task: AgentTask): string {
     return task.message + '\n';
@@ -33,18 +26,7 @@ export class EchoAdapter implements AgentAdapter {
     return [{ type: 'text-delta', text: line + '\n' }];
   }
 
-  async detect(): Promise<DetectionResult | null> {
-    try {
-      const { stdout } = await execFileAsync('which', ['cat'], { timeout: 5000 });
-      return {
-        binary: 'cat',
-        version: '1.0.0',
-        path: stdout.trim(),
-        tier: 1,
-        protocol: 'text',
-      };
-    } catch {
-      return null;
-    }
+  detect(): Promise<DetectionResult | null> {
+    return detectBinary('cat', 1, 'text');
   }
 }