openclaw-client 1.0.0

package/README.md

@@ -0,0 +1,127 @@
+# openclaw-client
+
+Lightweight TypeScript client for OpenClaw Gateway WebSocket RPC.
+
+## Installation
+
+```bash
+npm install openclaw-client
+# or
+pnpm add openclaw-client
+# or
+yarn add openclaw-client
+```
+
+## Quick Start
+
+```typescript
+import { OpenClawClient } from 'openclaw-client';
+
+const client = new OpenClawClient({
+  gatewayUrl: 'ws://localhost:18789',
+  token: 'your-token',
+  clientId: 'gateway-client',
+  mode: 'ui',
+});
+
+await client.connect();
+const sessions = await client.listSessions();
+```
+
+## Features
+
+- ✅ **Type-safe** - Auto-generated TypeScript types from OpenClaw protocol schema
+- ✅ **Lightweight** - Minimal dependencies, works in Node.js 18+ and browsers
+- ✅ **Event handling** - Listen to real-time events from the Gateway
+- ✅ **Server-friendly** - Includes utilities for server-side usage (Next.js, etc.)
+
+## API
+
+### `OpenClawClient`
+
+Main WebSocket client for OpenClaw Gateway.
+
+#### Configuration
+
+```typescript
+interface OpenClawClientConfig {
+  gatewayUrl: string;        // WebSocket URL (ws:// or wss://)
+  token: string;             // Authentication token
+  clientId?: string;         // Client identifier (default: 'webchat-ui')
+  clientVersion?: string;    // Client version (default: '1.0.0')
+  platform?: string;         // Platform name (default: 'web')
+  mode?: string;             // Client mode (default: 'ui')
+}
+```
+
+#### Methods
+
+- `connect(): Promise<HelloOk>` - Connect and authenticate
+- `disconnect(): void` - Disconnect from Gateway
+- `isConnected(): boolean` - Check connection status
+- `addEventListener(listener): () => void` - Add event listener
+- `getConfig(params?): Promise<any>` - Get configuration
+- `setConfig(params): Promise<any>` - Update configuration
+- `listSessions(params?): Promise<any>` - List sessions
+- `deleteSession(params): Promise<any>` - Delete a session
+- `listAgents(params?): Promise<AgentsListResult>` - List agents
+- `getAgentFile(params): Promise<AgentsFilesGetResult>` - Get agent file
+- `listAgentFiles(params): Promise<AgentsFilesListResult>` - List agent files
+- `setAgentFile(params): Promise<AgentsFilesSetResult>` - Update agent file
+- `listModels(params?): Promise<ModelsListResult>` - List available models
+- `getLogTail(params?): Promise<LogsTailResult>` - Get log tail
+- `call<T>(method, params?): Promise<T>` - Generic RPC method call
+
+### `ServerOpenClawClient`
+
+Server-side client manager for connection lifecycle management.
+
+```typescript
+import { ServerOpenClawClient, createServerClient } from 'openclaw-client';
+
+// Create from environment variables
+const serverClient = createServerClient();
+
+// Use with automatic connection management
+export async function myAction() {
+  return serverClient.withClient(async (client) => {
+    return await client.listSessions();
+  });
+}
+```
+
+Environment variables:
+- `OPENCLAW_GATEWAY_URL` - Gateway URL (default: `http://localhost:18789`)
+- `OPENCLAW_TOKEN` - Authentication token
+
+## Type Generation
+
+This package includes auto-generated types from the OpenClaw protocol schema.
+
+To regenerate types (for development):
+
+```bash
+npm run generate:types
+```
+
+The schema file is located at `src/protocol.schema.json` and is manually updated when the OpenClaw protocol changes.
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Generate types from schema
+npm run generate:types
+
+# Build the package
+npm run build
+
+# Publish to npm
+npm publish
+```
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,122 @@
+import type { AgentIdentityParams, AgentIdentityResult, AgentsFilesGetParams, AgentsFilesGetResult, AgentsFilesListParams, AgentsFilesListResult, AgentsFilesSetParams, AgentsFilesSetResult, AgentsListParams, AgentsListResult, ConfigGetParams, ConfigSchemaParams, ConfigSchemaResponse, ConfigSetParams, ConnectParams, EventFrame, HelloOk, LogsTailParams, LogsTailResult, ModelsListParams, ModelsListResult, SessionsDeleteParams, SessionsListParams } from './types';
+export interface OpenClawClientConfig {
+    gatewayUrl: string;
+    token: string;
+    clientId?: ConnectParams['client']['id'];
+    clientVersion?: string;
+    platform?: string;
+    mode?: ConnectParams['client']['mode'];
+}
+export type EventListener = (event: EventFrame) => void;
+export declare class OpenClawClient {
+    private ws;
+    private config;
+    private requestId;
+    private pending;
+    private eventListeners;
+    private connected;
+    private connectionId;
+    constructor(config: OpenClawClientConfig);
+    /**
+     * Connect to the OpenClaw Gateway and perform handshake
+     */
+    connect(): Promise<HelloOk>;
+    /**
+     * Disconnect from the Gateway
+     */
+    disconnect(): void;
+    /**
+     * Check if connected
+     */
+    isConnected(): boolean;
+    /**
+     * Get the current connection ID
+     */
+    getConnectionId(): string | null;
+    /**
+     * Add an event listener
+     */
+    addEventListener(listener: EventListener): () => void;
+    /**
+     * Perform the connection handshake
+     */
+    private handshake;
+    /**
+     * Send a request and wait for response
+     */
+    private request;
+    /**
+     * Handle incoming messages
+     */
+    private handleMessage;
+    /**
+     * Handle response frame
+     */
+    private handleResponse;
+    /**
+     * Handle event frame
+     */
+    private handleEvent;
+    /**
+     * Handle connection close
+     */
+    private handleClose;
+    /**
+     * Handle connection error
+     */
+    private handleError;
+    /**
+     * Get the current configuration
+     */
+    getConfig(params?: ConfigGetParams): Promise<any>;
+    /**
+     * Set configuration
+     */
+    setConfig(params: ConfigSetParams): Promise<any>;
+    /**
+     * Get configuration schema
+     */
+    getConfigSchema(params?: ConfigSchemaParams): Promise<ConfigSchemaResponse>;
+    /**
+     * List sessions
+     */
+    listSessions(params?: SessionsListParams): Promise<any>;
+    /**
+     * Delete a session
+     */
+    deleteSession(params: SessionsDeleteParams): Promise<any>;
+    /**
+     * Get agent file
+     */
+    getAgentFile(params: AgentsFilesGetParams): Promise<AgentsFilesGetResult>;
+    /**
+     * List agent files
+     */
+    listAgentFiles(params: AgentsFilesListParams): Promise<AgentsFilesListResult>;
+    /**
+     * Set agent file content
+     */
+    setAgentFile(params: AgentsFilesSetParams): Promise<AgentsFilesSetResult>;
+    /**
+     * List available agents
+     */
+    listAgents(params?: AgentsListParams): Promise<AgentsListResult>;
+    /**
+     * Get agent identity
+     */
+    getAgentIdentity(params?: AgentIdentityParams): Promise<AgentIdentityResult>;
+    /**
+     * List available models
+     */
+    listModels(params?: ModelsListParams): Promise<ModelsListResult>;
+    /**
+     * Get log tail
+     */
+    getLogTail(params?: LogsTailParams): Promise<LogsTailResult>;
+    /**
+     * Generic call method for any RPC method
+     * Use this for methods that don't have a dedicated wrapper
+     */
+    call<T = any>(method: string, params?: any): Promise<T>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}

package/dist/client.js

@@ -0,0 +1,294 @@
+// Get WebSocket constructor (works in both browser and Node.js 21+)
+const getWebSocketConstructor = () => {
+    if (typeof WebSocket !== 'undefined') {
+        return WebSocket;
+    }
+    throw new Error('WebSocket is not available in this environment');
+};
+export class OpenClawClient {
+    ws = null;
+    config;
+    requestId = 0;
+    pending = new Map();
+    eventListeners = [];
+    connected = false;
+    connectionId = null;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Connect to the OpenClaw Gateway and perform handshake
+     */
+    async connect() {
+        if (this.connected && this.ws?.readyState === WebSocket.OPEN) {
+            throw new Error('Already connected');
+        }
+        // Create WebSocket connection
+        const WS = getWebSocketConstructor();
+        this.ws = new WS(this.config.gatewayUrl);
+        // Wait for connection to open
+        await new Promise((resolve, reject) => {
+            if (!this.ws) {
+                reject(new Error('WebSocket not initialized'));
+                return;
+            }
+            this.ws.onopen = () => resolve();
+            this.ws.onerror = (error) => reject(error);
+        });
+        // Set up message handler
+        if (this.ws) {
+            this.ws.onmessage = (event) => this.handleMessage(event);
+            this.ws.onclose = () => this.handleClose();
+            this.ws.onerror = (error) => this.handleError(error);
+        }
+        // Perform handshake
+        const result = await this.handshake();
+        this.connected = true;
+        this.connectionId = result.server.connId;
+        return result;
+    }
+    /**
+     * Disconnect from the Gateway
+     */
+    disconnect() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.connected = false;
+        this.connectionId = null;
+        // Reject all pending requests
+        for (const [id, { reject }] of this.pending.entries()) {
+            reject(new Error('Connection closed'));
+            this.pending.delete(id);
+        }
+    }
+    /**
+     * Check if connected
+     */
+    isConnected() {
+        return this.connected && this.ws?.readyState === WebSocket.OPEN;
+    }
+    /**
+     * Get the current connection ID
+     */
+    getConnectionId() {
+        return this.connectionId;
+    }
+    /**
+     * Add an event listener
+     */
+    addEventListener(listener) {
+        this.eventListeners.push(listener);
+        return () => {
+            const index = this.eventListeners.indexOf(listener);
+            if (index > -1) {
+                this.eventListeners.splice(index, 1);
+            }
+        };
+    }
+    /**
+     * Perform the connection handshake
+     */
+    async handshake() {
+        const params = {
+            minProtocol: 3,
+            maxProtocol: 3,
+            client: {
+                id: this.config.clientId || 'webchat-ui',
+                version: this.config.clientVersion || '1.0.0',
+                platform: this.config.platform || 'web',
+                mode: this.config.mode || 'ui',
+            },
+            role: 'operator',
+            scopes: ['operator.read', 'operator.write', 'operator.admin'],
+            auth: {
+                token: this.config.token,
+            },
+        };
+        return this.request('connect', params);
+    }
+    /**
+     * Send a request and wait for response
+     */
+    async request(method, params) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('Not connected');
+        }
+        const id = `req-${++this.requestId}`;
+        const req = {
+            type: 'req',
+            id,
+            method,
+            params,
+        };
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            // Set timeout for request (30 seconds)
+            const timeout = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`Request timeout: ${method}`));
+            }, 30000);
+            // Clear timeout when promise settles
+            const originalResolve = resolve;
+            const originalReject = reject;
+            this.pending.set(id, {
+                resolve: (payload) => {
+                    clearTimeout(timeout);
+                    originalResolve(payload);
+                },
+                reject: (error) => {
+                    clearTimeout(timeout);
+                    originalReject(error);
+                },
+            });
+            this.ws.send(JSON.stringify(req));
+        });
+    }
+    /**
+     * Handle incoming messages
+     */
+    handleMessage(event) {
+        try {
+            const frame = JSON.parse(event.data);
+            if (frame.type === 'res') {
+                this.handleResponse(frame);
+            }
+            else if (frame.type === 'event') {
+                this.handleEvent(frame);
+            }
+        }
+        catch (error) {
+            console.error('Failed to parse message:', error);
+        }
+    }
+    /**
+     * Handle response frame
+     */
+    handleResponse(frame) {
+        const pending = this.pending.get(frame.id);
+        if (!pending) {
+            console.warn('Received response for unknown request:', frame.id);
+            return;
+        }
+        this.pending.delete(frame.id);
+        if (frame.ok) {
+            pending.resolve(frame.payload);
+        }
+        else {
+            const error = new Error(frame.error?.message || 'Request failed');
+            error.code = frame.error?.code;
+            error.details = frame.error?.details;
+            error.retryable = frame.error?.retryable;
+            pending.reject(error);
+        }
+    }
+    /**
+     * Handle event frame
+     */
+    handleEvent(frame) {
+        for (const listener of this.eventListeners) {
+            try {
+                listener(frame);
+            }
+            catch (error) {
+                console.error('Event listener error:', error);
+            }
+        }
+    }
+    /**
+     * Handle connection close
+     */
+    handleClose() {
+        this.connected = false;
+        console.log('WebSocket connection closed');
+    }
+    /**
+     * Handle connection error
+     */
+    handleError(error) {
+        console.error('WebSocket error:', error);
+    }
+    // ============================================================================
+    // Type-safe method wrappers based on schema
+    // ============================================================================
+    /**
+     * Get the current configuration
+     */
+    async getConfig(params = {}) {
+        return this.request('config.get', params);
+    }
+    /**
+     * Set configuration
+     */
+    async setConfig(params) {
+        return this.request('config.set', params);
+    }
+    /**
+     * Get configuration schema
+     */
+    async getConfigSchema(params = {}) {
+        return this.request('config.schema', params);
+    }
+    /**
+     * List sessions
+     */
+    async listSessions(params = {}) {
+        return this.request('sessions.list', params);
+    }
+    /**
+     * Delete a session
+     */
+    async deleteSession(params) {
+        return this.request('sessions.delete', params);
+    }
+    /**
+     * Get agent file
+     */
+    async getAgentFile(params) {
+        return this.request('agents.files.get', params);
+    }
+    /**
+     * List agent files
+     */
+    async listAgentFiles(params) {
+        return this.request('agents.files.list', params);
+    }
+    /**
+     * Set agent file content
+     */
+    async setAgentFile(params) {
+        return this.request('agents.files.set', params);
+    }
+    /**
+     * List available agents
+     */
+    async listAgents(params = {}) {
+        return this.request('agents.list', params);
+    }
+    /**
+     * Get agent identity
+     */
+    async getAgentIdentity(params = {}) {
+        return this.request('agent.identity', params);
+    }
+    /**
+     * List available models
+     */
+    async listModels(params = {}) {
+        return this.request('models.list', params);
+    }
+    /**
+     * Get log tail
+     */
+    async getLogTail(params = {}) {
+        return this.request('logs.tail', params);
+    }
+    /**
+     * Generic call method for any RPC method
+     * Use this for methods that don't have a dedicated wrapper
+     */
+    async call(method, params) {
+        return this.request(method, params);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './client';
+export * from './server-client';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './server-client';
+export * from './types';

package/dist/server-client.d.ts

@@ -0,0 +1,29 @@
+import { OpenClawClient, type OpenClawClientConfig } from './client';
+/**
+ * Server-side OpenClaw client manager
+ * Handles connection lifecycle for server actions
+ */
+export declare class ServerOpenClawClient {
+    private config;
+    private client;
+    constructor(config: OpenClawClientConfig);
+    /**
+     * Execute a function with a connected client
+     * Automatically handles connection and disconnection
+     */
+    withClient<T>(fn: (client: OpenClawClient) => Promise<T>): Promise<T>;
+    /**
+     * Get or create a persistent client connection
+     * Note: Use with caution in serverless environments
+     */
+    getClient(): Promise<OpenClawClient>;
+    /**
+     * Disconnect the persistent client
+     */
+    disconnect(): void;
+}
+/**
+ * Create a server OpenClaw client from environment variables
+ */
+export declare function createServerClient(): ServerOpenClawClient;
+//# sourceMappingURL=server-client.d.ts.map

package/dist/server-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-client.d.ts","sourceRoot":"","sources":["../src/server-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,KAAK,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAErE;;;GAGG;AACH,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,MAAM,CAA+B;gBAEjC,MAAM,EAAE,oBAAoB;IAIxC;;;OAGG;IACG,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAW3E;;;OAGG;IACG,SAAS,IAAI,OAAO,CAAC,cAAc,CAAC;IAQ1C;;OAEG;IACH,UAAU,IAAI,IAAI;CAMnB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,oBAAoB,CAazD"}

package/dist/server-client.js

@@ -0,0 +1,62 @@
+import { OpenClawClient } from './client';
+/**
+ * Server-side OpenClaw client manager
+ * Handles connection lifecycle for server actions
+ */
+export class ServerOpenClawClient {
+    config;
+    client = null;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Execute a function with a connected client
+     * Automatically handles connection and disconnection
+     */
+    async withClient(fn) {
+        const client = new OpenClawClient(this.config);
+        try {
+            await client.connect();
+            return await fn(client);
+        }
+        finally {
+            client.disconnect();
+        }
+    }
+    /**
+     * Get or create a persistent client connection
+     * Note: Use with caution in serverless environments
+     */
+    async getClient() {
+        if (!this.client || !this.client.isConnected()) {
+            this.client = new OpenClawClient(this.config);
+            await this.client.connect();
+        }
+        return this.client;
+    }
+    /**
+     * Disconnect the persistent client
+     */
+    disconnect() {
+        if (this.client) {
+            this.client.disconnect();
+            this.client = null;
+        }
+    }
+}
+/**
+ * Create a server OpenClaw client from environment variables
+ */
+export function createServerClient() {
+    // Convert HTTP URL to WebSocket URL
+    const gatewayUrl = process.env.OPENCLAW_GATEWAY_URL || 'http://localhost:18789';
+    const wsUrl = gatewayUrl.replace(/^http/, 'ws');
+    return new ServerOpenClawClient({
+        gatewayUrl: wsUrl,
+        token: process.env.OPENCLAW_TOKEN || '',
+        clientId: 'gateway-client',
+        clientVersion: '1.0.0',
+        platform: 'web',
+        mode: 'ui',
+    });
+}