@redonvn/event-ws-cliproxyapi-sdk 0.1.0

package/dist/shared/types.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../ws/types.js';
+export * from '../http/types.js';

package/dist/types/index.js

@@ -0,0 +1,2 @@
+export * from '../ws/types.js';
+export * from '../http/types.js';

package/dist/types.d.ts

@@ -0,0 +1,101 @@
+export type HTTPHeaders = Record<string, string | string[]>;
+export type WSHeaders = Record<string, string[]>;
+export interface HTTPRequest {
+    method: string;
+    url: string;
+    headers?: WSHeaders;
+    body?: string;
+    sent_at?: string;
+}
+export interface HTTPResponse {
+    status: number;
+    headers?: HTTPHeaders;
+    body?: string;
+}
+export interface WSHttpRequestPayload {
+    method: string;
+    url: string;
+    headers?: WSHeaders;
+    body?: string;
+    sent_at?: string;
+}
+export interface WSHttpResponsePayload {
+    status: number;
+    headers?: WSHeaders;
+    body?: string;
+}
+export interface WSStreamChunkPayload {
+    data: string;
+}
+export interface WSErrorPayload {
+    error: string;
+    status?: number;
+}
+export interface WSHttpRequestMessage {
+    id: string;
+    type: 'http_request';
+    payload: WSHttpRequestPayload;
+}
+export interface WSHttpResponseMessage {
+    id: string;
+    type: 'http_response';
+    payload: WSHttpResponsePayload;
+}
+export interface WSStreamStartMessage {
+    id: string;
+    type: 'stream_start';
+    payload: WSHttpResponsePayload;
+}
+export interface WSStreamChunkMessage {
+    id: string;
+    type: 'stream_chunk';
+    payload: WSStreamChunkPayload;
+}
+export interface WSStreamEndMessage {
+    id: string;
+    type: 'stream_end';
+    payload?: undefined;
+}
+export interface WSErrorMessage {
+    id: string;
+    type: 'error';
+    payload: WSErrorPayload;
+}
+export interface WSPingMessage {
+    id: string;
+    type: 'ping';
+    payload?: undefined;
+}
+export interface WSPongMessage {
+    id: string;
+    type: 'pong';
+    payload?: undefined;
+}
+export type WSMessage = WSHttpRequestMessage | WSHttpResponseMessage | WSStreamStartMessage | WSStreamChunkMessage | WSStreamEndMessage | WSErrorMessage | WSPingMessage | WSPongMessage;
+export interface ProviderOptions {
+    baseUrl: string;
+    accessKey?: string;
+}
+export type ProviderEvent = {
+    type: 'error';
+    requestId?: string;
+    error: string;
+} | {
+    type: 'ws:open';
+} | {
+    type: 'ws:close';
+    code?: number;
+    reason?: string;
+} | {
+    type: 'request';
+    requestId: string;
+    request: HTTPRequest;
+};
+export interface WSRequestContext {
+    requestId: string;
+    respond: (resp: HTTPResponse) => void;
+    streamStart: (status?: number, headers?: HTTPHeaders) => void;
+    streamChunk: (chunk: string) => void;
+    streamEnd: () => void;
+    error: (message: string, status?: number) => void;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/index.js

@@ -0,0 +1,2 @@
+"use strict";
+// Placeholder for shared utilities

package/dist/ws/client.d.ts

@@ -0,0 +1,20 @@
+import type { HTTPRequest, ProviderEvent, ProviderOptions, WSRequestContext } from './types.js';
+export interface ProviderHandlers {
+    onRequest: (req: HTTPRequest, ctx: WSRequestContext) => void | Promise<void>;
+    onEvent?: (ev: ProviderEvent) => void;
+}
+export declare class CliproxyWSProvider {
+    private ws?;
+    private options;
+    private handlers?;
+    constructor(options: ProviderOptions);
+    connect(handlers: ProviderHandlers): Promise<void>;
+    close(): void;
+    private handleMessage;
+    private handleClose;
+    private emitError;
+    private buildContext;
+    private sendMessage;
+}
+export declare class CliproxyWSClient extends CliproxyWSProvider {
+}

package/dist/ws/client.js

@@ -0,0 +1,114 @@
+import WebSocket from 'ws';
+import { decodeRequest, encodeChunk, encodeError, encodeResponse } from './codec.js';
+// CliproxyWSProvider connects to CLIProxyAPI /v1/ws and handles server->provider requests.
+// The websocket message shapes match CLIProxyAPI internal/wsrelay Message definitions.
+export class CliproxyWSProvider {
+    constructor(options) {
+        this.options = options;
+    }
+    // connect opens the websocket and starts processing incoming requests.
+    // It resolves once the socket is open.
+    connect(handlers) {
+        this.handlers = handlers;
+        if (this.ws && this.ws.readyState === WebSocket.OPEN)
+            return Promise.resolve();
+        const base = this.options.baseUrl.replace(/\/+$/, '');
+        const url = `${base.replace(/^http/, 'ws')}/v1/ws`;
+        const headers = {};
+        if (this.options.accessKey)
+            headers['Authorization'] = `Bearer ${this.options.accessKey}`;
+        this.ws = new WebSocket(url, { headers });
+        return new Promise((resolve, reject) => {
+            const ws = this.ws;
+            const onOpen = () => {
+                this.handlers?.onEvent?.({ type: 'ws:open' });
+                resolve();
+            };
+            const onErr = (err) => {
+                this.emitError(err?.message ?? 'wsrelay: connect error');
+                reject(err);
+            };
+            ws.once('open', onOpen);
+            ws.once('error', onErr);
+            ws.on('message', (raw) => this.handleMessage(raw.toString()));
+            ws.on('error', (err) => this.emitError(err?.message ?? 'wsrelay: socket error'));
+            ws.on('close', (code, reason) => this.handleClose(code, reason.toString()));
+        });
+    }
+    close() {
+        this.ws?.close();
+    }
+    handleMessage(raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            this.emitError('wsrelay: invalid message (json parse failed)');
+            return;
+        }
+        if (!msg || !msg.id || !msg.type) {
+            this.emitError('wsrelay: invalid message (missing id/type)');
+            return;
+        }
+        if (msg.type === 'ping') {
+            this.sendMessage('pong', msg.id);
+            return;
+        }
+        if (msg.type !== 'http_request')
+            return;
+        const req = decodeRequest(msg.payload);
+        const ctx = this.buildContext(msg.id);
+        this.handlers?.onEvent?.({ type: 'request', requestId: msg.id, request: req });
+        try {
+            const result = this.handlers?.onRequest(req, ctx);
+            if (result && typeof result.then === 'function') {
+                result.catch((err) => {
+                    const message = err?.message ?? 'provider error';
+                    ctx.error(message);
+                    this.emitError(message, msg?.id);
+                });
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : 'provider error';
+            ctx.error(message);
+            this.emitError(message, msg?.id);
+        }
+    }
+    handleClose(code, reason) {
+        this.handlers?.onEvent?.({ type: 'ws:close', code, reason });
+    }
+    emitError(error, requestId) {
+        this.handlers?.onEvent?.({ type: 'error', requestId, error });
+    }
+    buildContext(requestId) {
+        return {
+            requestId,
+            respond: (resp) => {
+                this.sendMessage('http_response', requestId, encodeResponse(resp));
+            },
+            streamStart: (status, headers) => {
+                const payload = encodeResponse({ status: status ?? 200, headers, body: '' });
+                this.sendMessage('stream_start', requestId, payload);
+            },
+            streamChunk: (chunk) => {
+                this.sendMessage('stream_chunk', requestId, encodeChunk(chunk));
+            },
+            streamEnd: () => {
+                this.sendMessage('stream_end', requestId);
+            },
+            error: (message, status) => {
+                this.sendMessage('error', requestId, encodeError(message, status));
+            }
+        };
+    }
+    sendMessage(type, id, payload) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return;
+        const msg = (payload === undefined ? { id, type } : { id, type, payload });
+        this.ws.send(JSON.stringify(msg));
+    }
+}
+export class CliproxyWSClient extends CliproxyWSProvider {
+}

package/dist/ws/codec.d.ts

@@ -0,0 +1,8 @@
+import type { HTTPRequest, HTTPResponse, WSErrorPayload, WSHttpRequestPayload, WSHttpResponsePayload, WSStreamChunkPayload } from './types.js';
+export declare function decodeRequest(payload?: WSHttpRequestPayload): HTTPRequest;
+export declare function encodeResponse(resp: HTTPResponse): WSHttpResponsePayload;
+export declare function decodeResponse(payload?: WSHttpResponsePayload): HTTPResponse;
+export declare function encodeChunk(chunk: string): WSStreamChunkPayload;
+export declare function decodeChunk(payload?: WSStreamChunkPayload): string;
+export declare function encodeError(message: string, status?: number): WSErrorPayload;
+export declare function decodeError(payload?: WSErrorPayload): string;

package/dist/ws/codec.js

@@ -0,0 +1,100 @@
+// Decode a server->provider request payload into an HTTPRequest.
+// Mirrors CLIProxyAPI wsrelay encodeRequest behavior.
+export function decodeRequest(payload) {
+    const method = typeof payload?.method === 'string' ? payload.method : 'GET';
+    const url = typeof payload?.url === 'string' ? payload.url : '';
+    const rawHeaders = payload?.headers;
+    const headers = {};
+    if (rawHeaders) {
+        for (const [key, raw] of Object.entries(rawHeaders)) {
+            if (Array.isArray(raw)) {
+                headers[key] = raw.map(String);
+            }
+            else if (typeof raw === 'string') {
+                headers[key] = [raw];
+            }
+        }
+    }
+    const body = typeof payload?.body === 'string' ? payload.body : '';
+    const sent_at = typeof payload?.sent_at === 'string' ? payload.sent_at : undefined;
+    return { method, url, headers, body, sent_at };
+}
+// Encode a provider response into the wsrelay HTTP response payload.
+export function encodeResponse(resp) {
+    const headers = {};
+    if (resp.headers) {
+        for (const [key, value] of Object.entries(resp.headers)) {
+            if (Array.isArray(value))
+                headers[key] = value.map(String);
+            else
+                headers[key] = [String(value)];
+        }
+    }
+    return {
+        status: resp.status ?? 200,
+        headers,
+        body: resp.body ?? ''
+    };
+}
+// Decode a wsrelay HTTP response payload into HTTPResponse.
+// CLIProxyAPI defaults to 502 when payload is missing.
+export function decodeResponse(payload) {
+    let status;
+    if (!payload) {
+        status = 502;
+    }
+    else if (typeof payload.status === 'number') {
+        status = payload.status;
+    }
+    else if (typeof payload.status === 'string') {
+        const parsed = Number(payload.status);
+        status = Number.isFinite(parsed) ? parsed : 200;
+    }
+    else {
+        status = 200;
+    }
+    const headers = {};
+    const rawHeaders = payload?.headers;
+    if (rawHeaders) {
+        for (const [key, raw] of Object.entries(rawHeaders)) {
+            if (Array.isArray(raw)) {
+                headers[key] = raw.map(String);
+            }
+            else if (typeof raw === 'string') {
+                headers[key] = raw;
+            }
+        }
+    }
+    const body = typeof payload?.body === 'string' ? payload.body : '';
+    return { status, headers, body };
+}
+// Encode a streaming chunk message payload.
+export function encodeChunk(chunk) {
+    return { data: chunk ?? '' };
+}
+// Decode a streaming chunk message payload.
+export function decodeChunk(payload) {
+    const data = payload?.data;
+    return typeof data === 'string' ? data : '';
+}
+// Encode an error payload. Status is optional but preferred when known.
+export function encodeError(message, status) {
+    const payload = { error: message || 'wsrelay: upstream error' };
+    if (typeof status === 'number' && !Number.isNaN(status)) {
+        payload.status = status;
+    }
+    return payload;
+}
+// Decode an error payload into a human-readable message.
+// CLIProxyAPI always formats as "message (status=...)".
+export function decodeError(payload) {
+    if (!payload)
+        return 'wsrelay: unknown error';
+    const message = typeof payload.error === 'string' ? payload.error : 'wsrelay: upstream error';
+    const status = typeof payload.status === 'number'
+        ? payload.status
+        : typeof payload.status === 'string'
+            ? Number(payload.status)
+            : 0;
+    return `${message} (status=${Number.isFinite(status) ? status : 0})`;
+}

package/dist/ws/index.d.ts

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

package/dist/ws/index.js

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

package/dist/ws/types.d.ts

@@ -0,0 +1,101 @@
+export type HTTPHeaders = Record<string, string | string[]>;
+export type WSHeaders = Record<string, string[]>;
+export interface HTTPRequest {
+    method: string;
+    url: string;
+    headers?: WSHeaders;
+    body?: string;
+    sent_at?: string;
+}
+export interface HTTPResponse {
+    status: number;
+    headers?: HTTPHeaders;
+    body?: string;
+}
+export interface WSHttpRequestPayload {
+    method: string;
+    url: string;
+    headers?: WSHeaders;
+    body?: string;
+    sent_at?: string;
+}
+export interface WSHttpResponsePayload {
+    status: number;
+    headers?: WSHeaders;
+    body?: string;
+}
+export interface WSStreamChunkPayload {
+    data: string;
+}
+export interface WSErrorPayload {
+    error: string;
+    status?: number;
+}
+export interface WSHttpRequestMessage {
+    id: string;
+    type: 'http_request';
+    payload: WSHttpRequestPayload;
+}
+export interface WSHttpResponseMessage {
+    id: string;
+    type: 'http_response';
+    payload: WSHttpResponsePayload;
+}
+export interface WSStreamStartMessage {
+    id: string;
+    type: 'stream_start';
+    payload: WSHttpResponsePayload;
+}
+export interface WSStreamChunkMessage {
+    id: string;
+    type: 'stream_chunk';
+    payload: WSStreamChunkPayload;
+}
+export interface WSStreamEndMessage {
+    id: string;
+    type: 'stream_end';
+    payload?: undefined;
+}
+export interface WSErrorMessage {
+    id: string;
+    type: 'error';
+    payload: WSErrorPayload;
+}
+export interface WSPingMessage {
+    id: string;
+    type: 'ping';
+    payload?: undefined;
+}
+export interface WSPongMessage {
+    id: string;
+    type: 'pong';
+    payload?: undefined;
+}
+export type WSMessage = WSHttpRequestMessage | WSHttpResponseMessage | WSStreamStartMessage | WSStreamChunkMessage | WSStreamEndMessage | WSErrorMessage | WSPingMessage | WSPongMessage;
+export interface ProviderOptions {
+    baseUrl: string;
+    accessKey?: string;
+}
+export type ProviderEvent = {
+    type: 'error';
+    requestId?: string;
+    error: string;
+} | {
+    type: 'ws:open';
+} | {
+    type: 'ws:close';
+    code?: number;
+    reason?: string;
+} | {
+    type: 'request';
+    requestId: string;
+    request: HTTPRequest;
+};
+export interface WSRequestContext {
+    requestId: string;
+    respond: (resp: HTTPResponse) => void;
+    streamStart: (status?: number, headers?: HTTPHeaders) => void;
+    streamChunk: (chunk: string) => void;
+    streamEnd: () => void;
+    error: (message: string, status?: number) => void;
+}

package/dist/ws/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@redonvn/event-ws-cliproxyapi-sdk",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "version": "0.1.0",
+  "description": "TypeScript SDK for CLIProxyAPI WebSocket relay (provider-side).",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsc -p tsconfig.json --watch",
+    "example": "node examples/run.js"
+  },
+  "dependencies": {
+    "ws": "^8.18.0",
+    "uuid": "^11.0.3"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.3",
+    "@types/ws": "^8.5.12"
+  }
+}