feat: Add TypeScript bindings with capabilities support

Author: tarunanand

bindings/typescript/.gitignore

@@ -0,0 +1,29 @@
+# TypeScript/Node ignores
+node_modules/
+dist/
+build/
+*.tsbuildinfo
+.env
+.env.*
+coverage/
+
+# napi-rs ignores
+*.node
+index.node
+*.d.ts
+artifacts/
+.napi/
+
+# Rust ignores
+target/
+Cargo.lock
+
+# IDE ignores
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS ignores
+.DS_Store
+Thumbs.db 

bindings/typescript/.placeholder

@@ -0,0 +1 @@
+

bindings/typescript/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "rmcp_typescript"
+edition.workspace = true
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+description.workspace = true
+keywords.workspace = true
+homepage.workspace = true
+categories.workspace = true
+readme.workspace = true
+
+[dependencies]
+rmcp = { path = "../../crates/rmcp", features = ["transport-sse", "client"] }
+napi = { version = "2", features = ["serde-json", "tokio_rt"] }
+napi-derive = "2"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.12", features = ["json"] }
+sse-stream = "0.1.3"
+url = "2.4"
+tokio = { version = "1.0", features = ["full"] }
+tokio-util = { version = "0.7", features = ["full"] }
+[lib]
+crate-type = ["cdylib"]
+
+[build-dependencies]
+napi-build = "2"

bindings/typescript/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    napi_build::setup();
+}

bindings/typescript/examples/clients/src/sse.ts

@@ -0,0 +1,70 @@
+// TypeScript SSE client example for rmcp_typescript
+// Closely mirrors the structure and flow of sse.rs from the core Rust SDK
+
+import { JsTransport, JsTransportEnum, JsClientInfo, JsImplementation } from '../../index';
+
+// TODO: Replace 'any' with proper types from WASM/SDK when available
+// type ClientCapabilities = any;
+// type CallToolRequestParam = { name: string; arguments?: object };
+
+async function main() {
+  // Step 1: Initialize logging (console-based for now)
+  console.info('Starting TypeScript SSE client example');
+
+  // Step 2: Create transport
+  const sseEndpoint = 'http://localhost:8000/sse';
+  const transport = new JsTransport(JsTransportEnum.SSE, sseEndpoint);
+
+  // Step 3: Define client info (mirror Rust structure)
+  const clientInfo: JsClientInfo = {
+    protocolVersion: '2024-11-05', // TODO: Use ProtocolVersion.latest() if available
+    capabilities: {}, // TODO: Use proper ClientCapabilities
+    clientInfo: {
+      name: 'typescript-sse-client',
+      version: '0.0.1',
+    },
+  };
+
+  try {
+    // Step 4: Connect and serve (stub for now)
+    transport.start(
+      (data: string) => {
+        console.log('Received SSE message:', data);
+        // TODO: Parse and handle protocol messages here (initialize, tool list, etc.)
+      },
+      (err: Event) => {
+        console.error('SSE error:', err);
+      }
+    );
+
+    // TODO: Replace with real async/await protocol flow when WASM/SDK methods are available
+    // Example (pseudo-code):
+    /*
+    const client = await clientInfo.serve(transport);
+    const serverInfo = client.peerInfo();
+    console.info('Connected to server:', serverInfo);
+
+    const tools = await client.listTools({});
+    console.info('Available tools:', tools);
+
+    const toolResult = await client.callTool({
+      name: 'increment',
+      arguments: {},
+    });
+    console.info('Tool result:', toolResult);
+
+    await client.cancel();
+    */
+
+    // For now, keep connection open for demonstration
+    setTimeout(() => {
+      transport.close();
+      console.info('Connection closed.');
+    }, 10000);
+
+  } catch (e) {
+    console.error('Client error:', e);
+  }
+}
+
+main();

bindings/typescript/package-lock.json

@@ -0,0 +1,16 @@
+{
+  "name": "rmcp-typescript",
+  "version": "0.1.0",
+  "description": "TypeScript/NodeJS native binding for the rmcp Rust SDK (napi-rs)",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "scripts": {
+    "build": "napi build --release",
+    "test": "tsc && node tests/add.test.js"
+  },
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  }
+}

bindings/typescript/package.json

@@ -0,0 +1,76 @@
+/**
+ * ClientInfo represents information about the client, such as protocol version, capabilities, and implementation details.
+ * This structure should mirror the Rust/Python SDK structure and will eventually be backed by WASM bindings.
+ */
+export interface ClientInfo {
+  protocolVersion: string;
+  capabilities: object; // Should be typed to ClientCapabilities
+  clientInfo: Implementation;
+}
+
+/**
+ * Implementation details for the client, such as name and version.
+ * This structure should mirror the Rust/Python SDK Implementation struct.
+ */
+export interface Implementation {
+  name: string;
+  version: string;
+}
+
+/**
+ * SSETransport provides an interface for connecting to an SSE (Server-Sent Events) endpoint.
+ * In the browser, this would use EventSource; in Node.js, a compatible polyfill or HTTP client.
+ * In the future, this should be backed by Rust/WASM for protocol logic.
+ */
+export class SSETransport {
+  private url: string;
+  private eventSource: EventSource | null = null;
+
+  /**
+   * Create a new SSETransport for the given URL.
+   * @param url The SSE endpoint URL.
+   */
+  constructor(url: string) {
+    this.url = url;
+  }
+
+  /**
+   * Start the SSE connection. In browser, uses EventSource. In Node, requires a polyfill.
+   * @param onMessage Callback for each message event.
+   * @param onError Callback for error events.
+   */
+  start(onMessage: (data: any) => void, onError?: (err: any) => void) {
+    if (typeof window !== 'undefined' && typeof window.EventSource !== 'undefined') {
+      this.eventSource = new window.EventSource(this.url);
+      this.eventSource.onmessage = (event) => {
+        onMessage(event.data);
+      };
+      if (onError) {
+        this.eventSource.onerror = onError;
+      }
+    } else {
+      // Node.js: User must provide a compatible EventSource polyfill
+      throw new Error('SSETransport requires EventSource (browser) or a polyfill (Node.js)');
+    }
+  }
+
+  /**
+   * Close the SSE connection.
+   */
+  close() {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+  }
+}
+
+/**
+ * IntoTransport is an interface for types that can be converted into a transport.
+ * This is a placeholder for extensibility and should mirror the Rust trait.
+ */
+export interface IntoTransport {
+  intoTransport(): SSETransport;
+}
+
+// TODO: When Rust/WASM bindings are available, replace these stubs with real implementations and types.

bindings/typescript/rmcp_typescript/index.ts

@@ -0,0 +1,2 @@
+// Client interface for rmcp_typescript binding
+// Add #[wasm_bindgen] wrappers as needed for TS/JS

bindings/typescript/src/client.rs

@@ -0,0 +1,25 @@
+pub mod model;
+pub mod client;
+pub mod service;
+pub mod transport;
+
+// Re-export capability types for WASM/TS bindings
+pub use model::capabilities::{
+    JsPromptsCapability,
+    JsResourcesCapability,
+    JsToolsCapability,
+    JsRootsCapabilities,
+    JsExperimentalCapabilities,
+    JsClientCapabilities,
+};
+
+// Re-export model types
+pub use model::{
+    JsClientInfo,
+    JsImplementation,
+    ProtocolVersion,
+};
+
+// Re-export service types
+pub use service::JsPeer;
+