agent-relay 2.0.32 → 2.0.34

package/packages/wrapper/src/opencode-api.test.ts

@@ -0,0 +1,292 @@
+/**
+ * Tests for OpenCode HTTP API client
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { OpenCodeApi } from './opencode-api.js';
+
+describe('OpenCodeApi', () => {
+  let originalFetch: typeof fetch;
+  let mockFetch: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    originalFetch = global.fetch;
+    mockFetch = vi.fn();
+    global.fetch = mockFetch;
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    vi.restoreAllMocks();
+  });
+
+  describe('constructor', () => {
+    it('should use default config values', () => {
+      const api = new OpenCodeApi();
+      // Access private properties for testing
+      expect((api as any).baseUrl).toBe('http://localhost:4096');
+      expect((api as any).timeout).toBe(5000);
+    });
+
+    it('should accept custom config', () => {
+      const api = new OpenCodeApi({
+        baseUrl: 'http://localhost:8080',
+        password: 'test-password',
+        timeout: 10000,
+      });
+      expect((api as any).baseUrl).toBe('http://localhost:8080');
+      expect((api as any).password).toBe('test-password');
+      expect((api as any).timeout).toBe(10000);
+    });
+  });
+
+  describe('getHeaders', () => {
+    it('should return content-type without auth when no password', () => {
+      const api = new OpenCodeApi();
+      const headers = (api as any).getHeaders();
+      expect(headers['Content-Type']).toBe('application/json');
+      expect(headers['Authorization']).toBeUndefined();
+    });
+
+    it('should include basic auth when password is set', () => {
+      const api = new OpenCodeApi({ password: 'secret' });
+      const headers = (api as any).getHeaders();
+      expect(headers['Content-Type']).toBe('application/json');
+      expect(headers['Authorization']).toBe('Basic ' + Buffer.from('opencode:secret').toString('base64'));
+    });
+  });
+
+  describe('isAvailable', () => {
+    it('should return true when server responds', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      const api = new OpenCodeApi();
+      const result = await api.isAvailable();
+
+      expect(result).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:4096/config',
+        expect.objectContaining({ method: 'GET' })
+      );
+    });
+
+    it('should return false when server unavailable', async () => {
+      mockFetch.mockRejectedValueOnce(new Error('Connection refused'));
+
+      const api = new OpenCodeApi();
+      const result = await api.isAvailable();
+
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('appendPrompt', () => {
+    it('should send text to append-prompt endpoint', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      const api = new OpenCodeApi();
+      const result = await api.appendPrompt('Hello, world!');
+
+      expect(result.success).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:4096/tui/append-prompt',
+        expect.objectContaining({
+          method: 'POST',
+          body: JSON.stringify({ text: 'Hello, world!' }),
+        })
+      );
+    });
+
+    it('should handle errors', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: false,
+        status: 500,
+        statusText: 'Internal Server Error',
+      });
+
+      const api = new OpenCodeApi();
+      const result = await api.appendPrompt('test');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('500');
+    });
+  });
+
+  describe('submitPrompt', () => {
+    it('should call submit-prompt endpoint', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      const api = new OpenCodeApi();
+      const result = await api.submitPrompt();
+
+      expect(result.success).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:4096/tui/submit-prompt',
+        expect.objectContaining({ method: 'POST' })
+      );
+    });
+  });
+
+  describe('clearPrompt', () => {
+    it('should call clear-prompt endpoint', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      const api = new OpenCodeApi();
+      const result = await api.clearPrompt();
+
+      expect(result.success).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:4096/tui/clear-prompt',
+        expect.objectContaining({ method: 'POST' })
+      );
+    });
+  });
+
+  describe('showToast', () => {
+    it('should send toast with default variant and duration', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      const api = new OpenCodeApi();
+      const result = await api.showToast('Test message');
+
+      expect(result.success).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:4096/tui/show-toast',
+        expect.objectContaining({
+          method: 'POST',
+          body: JSON.stringify({ message: 'Test message', variant: 'info', duration: 3000 }),
+        })
+      );
+    });
+
+    it('should send toast with custom variant and duration', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      const api = new OpenCodeApi();
+      const result = await api.showToast('Error!', { variant: 'error', duration: 5000 });
+
+      expect(result.success).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:4096/tui/show-toast',
+        expect.objectContaining({
+          body: JSON.stringify({ message: 'Error!', variant: 'error', duration: 5000 }),
+        })
+      );
+    });
+  });
+
+  describe('executeCommand', () => {
+    it('should send command to execute-command endpoint', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      const api = new OpenCodeApi();
+      const result = await api.executeCommand('session_new');
+
+      expect(result.success).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:4096/tui/execute-command',
+        expect.objectContaining({
+          method: 'POST',
+          body: JSON.stringify({ command: 'session_new' }),
+        })
+      );
+    });
+  });
+
+  describe('listSessions', () => {
+    it('should return sessions from API', async () => {
+      const mockSessions = [
+        { id: '1', title: 'Session 1', createdAt: '2024-01-01', updatedAt: '2024-01-02' },
+        { id: '2', title: 'Session 2', createdAt: '2024-01-03', updatedAt: '2024-01-04' },
+      ];
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockSessions),
+      });
+
+      const api = new OpenCodeApi();
+      const result = await api.listSessions();
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(mockSessions);
+    });
+  });
+
+  describe('getCurrentSession', () => {
+    it('should return current session', async () => {
+      const mockSession = { id: 'current', title: 'Current Session' };
+
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve(mockSession),
+      });
+
+      const api = new OpenCodeApi();
+      const result = await api.getCurrentSession();
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(mockSession);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:4096/session/current',
+        expect.objectContaining({ method: 'GET' })
+      );
+    });
+  });
+
+  describe('selectSession', () => {
+    it('should select session by id', async () => {
+      mockFetch.mockResolvedValueOnce({
+        ok: true,
+        json: () => Promise.resolve({}),
+      });
+
+      const api = new OpenCodeApi();
+      const result = await api.selectSession('session-123');
+
+      expect(result.success).toBe(true);
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://localhost:4096/tui/select-session',
+        expect.objectContaining({
+          method: 'POST',
+          body: JSON.stringify({ sessionID: 'session-123' }),
+        })
+      );
+    });
+  });
+
+  describe('request timeout', () => {
+    it('should handle timeout errors', async () => {
+      const abortError = new Error('The operation was aborted');
+      abortError.name = 'AbortError';
+      mockFetch.mockRejectedValueOnce(abortError);
+
+      const api = new OpenCodeApi({ timeout: 100 });
+      const result = await api.appendPrompt('test');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Request timeout');
+    });
+  });
+});

package/packages/wrapper/src/opencode-api.ts

@@ -0,0 +1,285 @@
+/**
+ * OpenCode HTTP API client
+ *
+ * Provides integration with opencode serve's HTTP API for:
+ * - Injecting text into the TUI input field (append-prompt)
+ * - Submitting prompts
+ * - Clearing prompts
+ * - Session management
+ *
+ * @see https://github.com/anomalyco/opencode
+ */
+
+export interface OpenCodeApiConfig {
+  /** Base URL for opencode serve (default: http://localhost:4096) */
+  baseUrl?: string;
+  /** Server password if authentication is enabled (OPENCODE_SERVER_PASSWORD) */
+  password?: string;
+  /** Request timeout in milliseconds (default: 5000) */
+  timeout?: number;
+}
+
+export interface OpenCodeSession {
+  id: string;
+  title?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface OpenCodeApiResponse<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}
+
+/**
+ * OpenCode HTTP API client for interacting with opencode serve
+ */
+export class OpenCodeApi {
+  private baseUrl: string;
+  private password?: string;
+  private timeout: number;
+
+  constructor(config: OpenCodeApiConfig = {}) {
+    // Priority: explicit config > OPENCODE_API_URL env > OPENCODE_PORT env > default
+    const defaultPort = process.env.OPENCODE_PORT ?? '4096';
+    const defaultUrl = process.env.OPENCODE_API_URL ?? `http://localhost:${defaultPort}`;
+    this.baseUrl = config.baseUrl ?? defaultUrl;
+    this.password = config.password ?? process.env.OPENCODE_SERVER_PASSWORD;
+    this.timeout = config.timeout ?? 5000;
+  }
+
+  /**
+   * Build authorization headers if password is set
+   */
+  private getHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+    if (this.password) {
+      // Basic auth with 'opencode' as username
+      const auth = Buffer.from(`opencode:${this.password}`).toString('base64');
+      headers['Authorization'] = `Basic ${auth}`;
+    }
+    return headers;
+  }
+
+  /**
+   * Make a request to the opencode API
+   */
+  private async request<T>(
+    method: 'GET' | 'POST' | 'DELETE',
+    path: string,
+    body?: unknown
+  ): Promise<OpenCodeApiResponse<T>> {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        method,
+        headers: this.getHeaders(),
+        body: body ? JSON.stringify(body) : undefined,
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        return {
+          success: false,
+          error: `HTTP ${response.status}: ${response.statusText}`,
+        };
+      }
+
+      const data = await response.json() as T;
+      return { success: true, data };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error) {
+        if (error.name === 'AbortError') {
+          return { success: false, error: 'Request timeout' };
+        }
+        return { success: false, error: error.message };
+      }
+      return { success: false, error: 'Unknown error' };
+    }
+  }
+
+  // =========================================================================
+  // Health Check
+  // =========================================================================
+
+  /**
+   * Check if opencode serve is running and accessible
+   */
+  async isAvailable(): Promise<boolean> {
+    try {
+      const response = await this.request<{ version: string }>('GET', '/config');
+      return response.success;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Wait for opencode serve to become available
+   * @param maxWaitMs Maximum time to wait in milliseconds (default: 10000)
+   * @param intervalMs Check interval in milliseconds (default: 500)
+   */
+  async waitForAvailable(maxWaitMs = 10000, intervalMs = 500): Promise<boolean> {
+    const startTime = Date.now();
+    while (Date.now() - startTime < maxWaitMs) {
+      if (await this.isAvailable()) {
+        return true;
+      }
+      await new Promise(resolve => setTimeout(resolve, intervalMs));
+    }
+    return false;
+  }
+
+  // =========================================================================
+  // TUI Control
+  // =========================================================================
+
+  /**
+   * Append text to the TUI input field
+   * This is the primary method for injecting relay messages into opencode
+   */
+  async appendPrompt(text: string): Promise<OpenCodeApiResponse<boolean>> {
+    return this.request<boolean>('POST', '/tui/append-prompt', { text });
+  }
+
+  /**
+   * Submit the current prompt
+   */
+  async submitPrompt(): Promise<OpenCodeApiResponse<boolean>> {
+    return this.request<boolean>('POST', '/tui/submit-prompt');
+  }
+
+  /**
+   * Clear the current prompt
+   */
+  async clearPrompt(): Promise<OpenCodeApiResponse<boolean>> {
+    return this.request<boolean>('POST', '/tui/clear-prompt');
+  }
+
+  /**
+   * Show a toast notification in the TUI
+   */
+  async showToast(
+    message: string,
+    options?: { variant?: 'info' | 'success' | 'warning' | 'error'; duration?: number }
+  ): Promise<OpenCodeApiResponse<boolean>> {
+    return this.request<boolean>('POST', '/tui/show-toast', {
+      message,
+      variant: options?.variant ?? 'info',
+      duration: options?.duration ?? 3000,
+    });
+  }
+
+  /**
+   * Execute a TUI command
+   */
+  async executeCommand(
+    command:
+      | 'session_new'
+      | 'session_share'
+      | 'session_interrupt'
+      | 'session_compact'
+      | 'agent_cycle'
+      | 'messages_page_up'
+      | 'messages_page_down'
+  ): Promise<OpenCodeApiResponse<boolean>> {
+    return this.request<boolean>('POST', '/tui/execute-command', { command });
+  }
+
+  // =========================================================================
+  // Session Management
+  // =========================================================================
+
+  /**
+   * List all sessions
+   */
+  async listSessions(): Promise<OpenCodeApiResponse<OpenCodeSession[]>> {
+    return this.request<OpenCodeSession[]>('GET', '/session');
+  }
+
+  /**
+   * Get the current session
+   */
+  async getCurrentSession(): Promise<OpenCodeApiResponse<OpenCodeSession>> {
+    return this.request<OpenCodeSession>('GET', '/session/current');
+  }
+
+  /**
+   * Select a session in the TUI
+   */
+  async selectSession(sessionId: string): Promise<OpenCodeApiResponse<boolean>> {
+    return this.request<boolean>('POST', '/tui/select-session', { sessionID: sessionId });
+  }
+
+  // =========================================================================
+  // Events (SSE)
+  // =========================================================================
+
+  /**
+   * Subscribe to opencode events via Server-Sent Events
+   * Returns an abort function to stop the subscription
+   */
+  subscribeToEvents(
+    onEvent: (event: { type: string; data: unknown }) => void,
+    onError?: (error: Error) => void
+  ): () => void {
+    const controller = new AbortController();
+
+    const connect = async () => {
+      try {
+        const response = await fetch(`${this.baseUrl}/event`, {
+          headers: this.getHeaders(),
+          signal: controller.signal,
+        });
+
+        if (!response.ok || !response.body) {
+          throw new Error(`SSE connection failed: ${response.status}`);
+        }
+
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split('\n');
+          buffer = lines.pop() ?? '';
+
+          for (const line of lines) {
+            if (line.startsWith('data: ')) {
+              try {
+                const data = JSON.parse(line.slice(6));
+                onEvent(data);
+              } catch {
+                // Ignore parse errors
+              }
+            }
+          }
+        }
+      } catch (error) {
+        if (error instanceof Error && error.name !== 'AbortError') {
+          onError?.(error);
+        }
+      }
+    };
+
+    connect();
+    return () => controller.abort();
+  }
+}
+
+/**
+ * Default OpenCode API instance
+ */
+export const openCodeApi = new OpenCodeApi();