starpc 0.46.0 → 0.46.2

package/integration/cross-language/go-client/main.go

@@ -0,0 +1,151 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net"
+	"os"
+
+	"github.com/aperturerobotics/starpc/echo"
+	"github.com/aperturerobotics/starpc/srpc"
+)
+
+const bodyTxt = "hello world via starpc cross-language e2e test"
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Fprintf(os.Stderr, "usage: go-client <addr>\n")
+		os.Exit(1)
+	}
+	addr := os.Args[1]
+
+	openStream := func(ctx context.Context, msgHandler srpc.PacketDataHandler, closeHandler srpc.CloseHandler) (srpc.PacketWriter, error) {
+		conn, err := net.Dial("tcp", addr)
+		if err != nil {
+			return nil, err
+		}
+		prw := srpc.NewPacketReadWriter(conn)
+		go prw.ReadPump(msgHandler, closeHandler)
+		return prw, nil
+	}
+
+	client := srpc.NewClient(openStream)
+	echoClient := echo.NewSRPCEchoerClient(client)
+	ctx := context.Background()
+
+	if err := testUnary(ctx, echoClient); err != nil {
+		fmt.Fprintf(os.Stderr, "unary test failed: %v\n", err)
+		os.Exit(1)
+	}
+
+	if err := testServerStream(ctx, echoClient); err != nil {
+		fmt.Fprintf(os.Stderr, "server stream test failed: %v\n", err)
+		os.Exit(1)
+	}
+
+	if err := testClientStream(ctx, echoClient); err != nil {
+		fmt.Fprintf(os.Stderr, "client stream test failed: %v\n", err)
+		os.Exit(1)
+	}
+
+	if err := testBidiStream(ctx, echoClient); err != nil {
+		fmt.Fprintf(os.Stderr, "bidi stream test failed: %v\n", err)
+		os.Exit(1)
+	}
+
+	fmt.Println("All tests passed.")
+}
+
+func testUnary(ctx context.Context, client echo.SRPCEchoerClient) error {
+	fmt.Println("Testing Unary RPC...")
+	out, err := client.Echo(ctx, &echo.EchoMsg{Body: bodyTxt})
+	if err != nil {
+		return fmt.Errorf("echo call: %w", err)
+	}
+	if out.GetBody() != bodyTxt {
+		return fmt.Errorf("expected %q got %q", bodyTxt, out.GetBody())
+	}
+	fmt.Println("  PASSED")
+	return nil
+}
+
+func testServerStream(ctx context.Context, client echo.SRPCEchoerClient) error {
+	fmt.Println("Testing ServerStream RPC...")
+	strm, err := client.EchoServerStream(ctx, &echo.EchoMsg{Body: bodyTxt})
+	if err != nil {
+		return fmt.Errorf("echo server stream call: %w", err)
+	}
+	received := 0
+	for {
+		msg, err := strm.Recv()
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return fmt.Errorf("recv: %w", err)
+		}
+		if msg.GetBody() != bodyTxt {
+			return fmt.Errorf("expected %q got %q", bodyTxt, msg.GetBody())
+		}
+		received++
+	}
+	if received != 5 {
+		return fmt.Errorf("expected 5 messages, got %d", received)
+	}
+	fmt.Println("  PASSED")
+	return nil
+}
+
+func testClientStream(ctx context.Context, client echo.SRPCEchoerClient) error {
+	fmt.Println("Testing ClientStream RPC...")
+	strm, err := client.EchoClientStream(ctx)
+	if err != nil {
+		return fmt.Errorf("echo client stream call: %w", err)
+	}
+	if err := strm.MsgSend(&echo.EchoMsg{Body: bodyTxt}); err != nil {
+		return fmt.Errorf("send: %w", err)
+	}
+	resp := &echo.EchoMsg{}
+	if err := strm.MsgRecv(resp); err != nil {
+		return fmt.Errorf("recv: %w", err)
+	}
+	if resp.GetBody() != bodyTxt {
+		return fmt.Errorf("expected %q got %q", bodyTxt, resp.GetBody())
+	}
+	_ = strm.Close()
+	fmt.Println("  PASSED")
+	return nil
+}
+
+func testBidiStream(ctx context.Context, client echo.SRPCEchoerClient) error {
+	fmt.Println("Testing BidiStream RPC...")
+	strm, err := client.EchoBidiStream(ctx)
+	if err != nil {
+		return fmt.Errorf("echo bidi stream call: %w", err)
+	}
+
+	// server sends initial message
+	msg, err := strm.Recv()
+	if err != nil {
+		return fmt.Errorf("recv initial: %w", err)
+	}
+	if msg.GetBody() != "hello from server" {
+		return fmt.Errorf("expected %q got %q", "hello from server", msg.GetBody())
+	}
+
+	// send a message and expect echo
+	if err := strm.MsgSend(&echo.EchoMsg{Body: bodyTxt}); err != nil {
+		return fmt.Errorf("send: %w", err)
+	}
+	msg, err = strm.Recv()
+	if err != nil {
+		return fmt.Errorf("recv echo: %w", err)
+	}
+	if msg.GetBody() != bodyTxt {
+		return fmt.Errorf("expected %q got %q", bodyTxt, msg.GetBody())
+	}
+	_ = strm.Close()
+	fmt.Println("  PASSED")
+	return nil
+}

package/integration/cross-language/go-server/main.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"os"
+	"os/signal"
+
+	"github.com/aperturerobotics/starpc/echo"
+	"github.com/aperturerobotics/starpc/srpc"
+)
+
+func main() {
+	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt)
+	defer cancel()
+
+	mux := srpc.NewMux()
+	echoServer := echo.NewEchoServer(mux)
+	if err := echo.SRPCRegisterEchoer(mux, echoServer); err != nil {
+		fmt.Fprintf(os.Stderr, "register error: %v\n", err)
+		os.Exit(1)
+	}
+	server := srpc.NewServer(mux)
+
+	ln, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "listen error: %v\n", err)
+		os.Exit(1)
+	}
+	defer ln.Close()
+
+	fmt.Printf("LISTENING %s\n", ln.Addr().String())
+
+	go func() {
+		<-ctx.Done()
+		ln.Close()
+	}()
+
+	for {
+		conn, err := ln.Accept()
+		if err != nil {
+			return
+		}
+		go server.HandleStream(ctx, conn)
+	}
+}

package/integration/cross-language/run.bash

@@ -0,0 +1,193 @@
+#!/bin/bash
+# Cross-language integration tests for starpc.
+# Runs all 12 server/client combinations across Go, TypeScript, Rust, and C++.
+#
+# Usage:
+#   ./run.bash              # Run all pairs
+#   ./run.bash go:ts        # Run go-server+ts-client and ts-server+go-client
+#   ./run.bash go:ts go:rust # Run multiple pair filters
+set -eo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
+
+# Fixes errors with the generated esm using require()
+ESM_BANNER='import{fileURLToPath}from"node:url";import{dirname}from"node:path";import{createRequire as topLevelCreateRequire}from"node:module";const require=topLevelCreateRequire(import.meta.url);const __filename=fileURLToPath(import.meta.url);const __dirname=dirname(__filename);'
+
+FILTERS=("$@")
+
+PASSED=0
+FAILED=0
+ERRORS=""
+
+# should_run checks if a test name matches the active filters.
+# Returns 0 (true) if the test should run, 1 (false) otherwise.
+should_run() {
+    local test_name="$1"
+    if [ ${#FILTERS[@]} -eq 0 ]; then
+        return 0
+    fi
+    for filter in "${FILTERS[@]}"; do
+        local lang1="${filter%%:*}"
+        local lang2="${filter##*:}"
+        if [[ "$test_name" == *"${lang1}-"* && "$test_name" == *"${lang2}-"* ]]; then
+            return 0
+        fi
+    done
+    return 1
+}
+
+# Build all binaries.
+echo "=== Building all integration binaries ==="
+
+echo "Building Go server/client..."
+go build -o "$SCRIPT_DIR/go-server/go-server" "$SCRIPT_DIR/go-server/"
+go build -o "$SCRIPT_DIR/go-client/go-client" "$SCRIPT_DIR/go-client/"
+
+echo "Building TypeScript server/client..."
+"$REPO_DIR/node_modules/.bin/esbuild" "$SCRIPT_DIR/ts-server.ts" \
+    --bundle --sourcemap --platform=node --format=esm \
+    --banner:js="$ESM_BANNER" \
+    --outfile="$SCRIPT_DIR/ts-server.mjs"
+"$REPO_DIR/node_modules/.bin/esbuild" "$SCRIPT_DIR/ts-client.ts" \
+    --bundle --sourcemap --platform=node --format=esm \
+    --banner:js="$ESM_BANNER" \
+    --outfile="$SCRIPT_DIR/ts-client.mjs"
+
+echo "Building Rust server/client..."
+cargo build --release --bin integration-server --bin integration-client 2>&1 | grep -v "^warning:" || true
+
+echo "Building C++ server/client..."
+mkdir -p "$REPO_DIR/build"
+pushd "$REPO_DIR/build" > /dev/null
+cmake "$REPO_DIR" -DCMAKE_BUILD_TYPE=Release > /dev/null 2>&1
+cmake --build . --target cpp-integration-server cpp-integration-client --parallel > /dev/null 2>&1
+popd > /dev/null
+
+# Binary paths.
+GO_SERVER="$SCRIPT_DIR/go-server/go-server"
+GO_CLIENT="$SCRIPT_DIR/go-client/go-client"
+TS_SERVER="$SCRIPT_DIR/ts-server.mjs"
+TS_CLIENT="$SCRIPT_DIR/ts-client.mjs"
+RUST_SERVER="$REPO_DIR/target/release/integration-server"
+RUST_CLIENT="$REPO_DIR/target/release/integration-client"
+CPP_SERVER="$REPO_DIR/build/cpp-integration-server"
+CPP_CLIENT="$REPO_DIR/build/cpp-integration-client"
+
+# Start a server and capture its address.
+# Sets SERVER_PID and SERVER_ADDR.
+start_server() {
+    local addr_file
+    addr_file=$(mktemp)
+    "$@" > "$addr_file" 2>&1 &
+    SERVER_PID=$!
+    # Wait for LISTENING output (up to 3 seconds).
+    local waited=0
+    while [ $waited -lt 30 ]; do
+        if grep -q 'LISTENING' "$addr_file" 2>/dev/null; then
+            break
+        fi
+        sleep 0.1
+        waited=$((waited + 1))
+    done
+    SERVER_ADDR=$(grep 'LISTENING' "$addr_file" 2>/dev/null | awk '{print $2}')
+    rm -f "$addr_file"
+    if [ -z "$SERVER_ADDR" ]; then
+        echo "FAILED: server did not start"
+        kill $SERVER_PID 2>/dev/null || true
+        return 1
+    fi
+    return 0
+}
+
+stop_server() {
+    kill $SERVER_PID 2>/dev/null || true
+    wait $SERVER_PID 2>/dev/null || true
+}
+
+# run_pair <test_name> <server_args...> -- <client_args...>
+# The client receives $SERVER_ADDR as its last argument.
+run_pair() {
+    local test_name="$1"
+    shift
+
+    if ! should_run "$test_name"; then
+        return
+    fi
+
+    # Split args on "--".
+    local srv_args=()
+    local cli_args=()
+    local in_client=false
+    for arg in "$@"; do
+        if [ "$arg" = "--" ]; then
+            in_client=true
+            continue
+        fi
+        if $in_client; then
+            cli_args+=("$arg")
+        else
+            srv_args+=("$arg")
+        fi
+    done
+
+    echo -n "  ${test_name}... "
+
+    if ! start_server "${srv_args[@]}"; then
+        echo "FAILED (server start)"
+        FAILED=$((FAILED + 1))
+        ERRORS="${ERRORS}\n  ${test_name} (server start failed)"
+        return
+    fi
+
+    local client_out
+    client_out=$(mktemp)
+    if "${cli_args[@]}" "$SERVER_ADDR" > "$client_out" 2>&1; then
+        echo "PASSED"
+        PASSED=$((PASSED + 1))
+    else
+        echo "FAILED"
+        FAILED=$((FAILED + 1))
+        ERRORS="${ERRORS}\n  ${test_name}"
+        echo "    client output:"
+        sed 's/^/    /' "$client_out"
+    fi
+    rm -f "$client_out"
+
+    stop_server
+}
+
+echo ""
+echo "=== Running cross-language integration tests ==="
+echo ""
+
+# Go server combinations
+run_pair "go-server + go-client"   "$GO_SERVER" -- "$GO_CLIENT"
+run_pair "go-server + rust-client" "$GO_SERVER" -- "$RUST_CLIENT"
+run_pair "go-server + ts-client"   "$GO_SERVER" -- node "$TS_CLIENT"
+run_pair "go-server + cpp-client"  "$GO_SERVER" -- "$CPP_CLIENT"
+
+# Rust server combinations
+run_pair "rust-server + go-client"   "$RUST_SERVER" -- "$GO_CLIENT"
+run_pair "rust-server + rust-client" "$RUST_SERVER" -- "$RUST_CLIENT"
+run_pair "rust-server + ts-client"   "$RUST_SERVER" -- node "$TS_CLIENT"
+run_pair "rust-server + cpp-client"  "$RUST_SERVER" -- "$CPP_CLIENT"
+
+# TypeScript server combinations
+run_pair "ts-server + go-client"   node "$TS_SERVER" -- "$GO_CLIENT"
+run_pair "ts-server + rust-client" node "$TS_SERVER" -- "$RUST_CLIENT"
+run_pair "ts-server + ts-client"   node "$TS_SERVER" -- node "$TS_CLIENT"
+run_pair "ts-server + cpp-client"  node "$TS_SERVER" -- "$CPP_CLIENT"
+
+# C++ server combinations
+run_pair "cpp-server + go-client"   "$CPP_SERVER" -- "$GO_CLIENT"
+run_pair "cpp-server + rust-client" "$CPP_SERVER" -- "$RUST_CLIENT"
+run_pair "cpp-server + ts-client"   "$CPP_SERVER" -- node "$TS_CLIENT"
+run_pair "cpp-server + cpp-client"  "$CPP_SERVER" -- "$CPP_CLIENT"
+
+echo ""
+echo "=== Results: ${PASSED} passed, ${FAILED} failed ==="
+if [ $FAILED -gt 0 ]; then
+    echo -e "Failed tests:${ERRORS}"
+    exit 1
+fi

package/integration/cross-language/ts-client.ts

@@ -0,0 +1,84 @@
+import net from 'net'
+import { pipe } from 'it-pipe'
+import { pushable } from 'it-pushable'
+import { Client } from '../../srpc/client.js'
+import {
+  parseLengthPrefixTransform,
+  prependLengthPrefixTransform,
+} from '../../srpc/packet.js'
+import { combineUint8ArrayListTransform } from '../../srpc/array-list.js'
+import { runClientTest } from '../../echo/client-test.js'
+import type { OpenStreamFunc, PacketStream } from '../../srpc/stream.js'
+import type { Source } from 'it-stream-types'
+
+// tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
+function tcpSocketToPacketStream(socket: net.Socket): PacketStream {
+  const socketSource = async function* (): AsyncGenerator<Uint8Array> {
+    const source = pushable<Uint8Array>({ objectMode: true })
+    socket.on('data', (data: Buffer) => {
+      source.push(new Uint8Array(data))
+    })
+    socket.on('end', () => source.end())
+    socket.on('error', (err) => source.end(err))
+    socket.on('close', () => source.end())
+    yield* pipe(
+      source,
+      parseLengthPrefixTransform(),
+      combineUint8ArrayListTransform(),
+    )
+  }
+
+  return {
+    source: socketSource(),
+    sink: async (source: Source<Uint8Array>): Promise<void> => {
+      for await (const chunk of pipe(source, prependLengthPrefixTransform())) {
+        const data =
+          chunk instanceof Uint8Array ? chunk : (chunk as any).subarray()
+        await new Promise<void>((resolve, reject) => {
+          socket.write(data, (err) => {
+            if (err) reject(err)
+            else resolve()
+          })
+        })
+      }
+      socket.end()
+    },
+  }
+}
+
+async function main() {
+  const addr = process.argv[2]
+  if (!addr) {
+    console.error('usage: ts-client <host:port>')
+    process.exit(1)
+  }
+
+  const [host, portStr] = addr.split(':')
+  const port = parseInt(portStr, 10)
+
+  const openStream: OpenStreamFunc = async (): Promise<PacketStream> => {
+    return new Promise((resolve, reject) => {
+      const socket = net.connect(port, host, () => {
+        resolve(tcpSocketToPacketStream(socket))
+      })
+      socket.on('error', reject)
+    })
+  }
+
+  const client = new Client(openStream)
+
+  console.log('Running client test via TCP...')
+  await runClientTest(client)
+  console.log('All tests passed.')
+  process.exit(0)
+}
+
+process.on('unhandledRejection', (ev) => {
+  console.error('Unhandled rejection', ev)
+  process.exit(1)
+})
+
+main().catch((err) => {
+  console.error('Error:', err)
+  process.exit(1)
+})

package/integration/cross-language/ts-server.ts

@@ -0,0 +1,75 @@
+import net from 'net'
+import { pipe } from 'it-pipe'
+import { pushable } from 'it-pushable'
+import { createMux, createHandler, Server } from '../../srpc/index.js'
+import {
+  parseLengthPrefixTransform,
+  prependLengthPrefixTransform,
+} from '../../srpc/packet.js'
+import { combineUint8ArrayListTransform } from '../../srpc/array-list.js'
+import { EchoerServer } from '../../echo/server.js'
+import { EchoerDefinition } from '../../echo/echo_srpc.pb.js'
+import type { PacketStream } from '../../srpc/stream.js'
+import type { Source } from 'it-stream-types'
+
+// tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
+// Each Uint8Array in source/sink is one packet (no length prefix).
+function tcpSocketToPacketStream(socket: net.Socket): PacketStream {
+  // Source: read from socket, strip length prefix, yield individual packets.
+  const socketSource = async function* (): AsyncGenerator<Uint8Array> {
+    const source = pushable<Uint8Array>({ objectMode: true })
+    socket.on('data', (data: Buffer) => {
+      source.push(new Uint8Array(data))
+    })
+    socket.on('end', () => source.end())
+    socket.on('error', (err) => source.end(err))
+    socket.on('close', () => source.end())
+    yield* pipe(
+      source,
+      parseLengthPrefixTransform(),
+      combineUint8ArrayListTransform(),
+    )
+  }
+
+  return {
+    source: socketSource(),
+    sink: async (source: Source<Uint8Array>): Promise<void> => {
+      for await (const chunk of pipe(source, prependLengthPrefixTransform())) {
+        const data =
+          chunk instanceof Uint8Array ? chunk : (chunk as any).subarray()
+        await new Promise<void>((resolve, reject) => {
+          socket.write(data, (err) => {
+            if (err) reject(err)
+            else resolve()
+          })
+        })
+      }
+      socket.end()
+    },
+  }
+}
+
+const mux = createMux()
+const server = new Server(mux.lookupMethod)
+const echoer = new EchoerServer(server)
+mux.register(createHandler(EchoerDefinition, echoer))
+
+const tcpServer = net.createServer((socket) => {
+  const stream = tcpSocketToPacketStream(socket)
+  server.handlePacketStream(stream)
+})
+
+tcpServer.listen(0, '127.0.0.1', () => {
+  const addr = tcpServer.address() as net.AddressInfo
+  console.log(`LISTENING ${addr.address}:${addr.port}`)
+})
+
+process.on('SIGINT', () => {
+  tcpServer.close()
+  process.exit(0)
+})
+
+process.on('SIGTERM', () => {
+  tcpServer.close()
+  process.exit(0)
+})

package/integration/integration.bash

@@ -1,4 +1,6 @@
 #!/bin/bash
+# Go<->TypeScript integration test: Go WebSocket server + TypeScript client.
+# For cross-language tests across all 4 languages, see integration/cross-language/.
 set -eo pipefail
 
 unset GOOS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.46.0",
+  "version": "0.46.2",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -81,8 +81,13 @@
     "test:js": "vitest run",
     "test:js:watch": "vitest",
     "debug:js": "bun run build:e2e && cd e2e && node --inspect --inspect-brk ./e2e.cjs",
-    "test:integration": "cd ./integration && bash ./integration.bash",
-    "integration": "bun run test:integration",
+    "integration": "bash ./integration/cross-language/run.bash",
+    "integration:go:ts": "bash ./integration/cross-language/run.bash go:ts",
+    "integration:go:rust": "bash ./integration/cross-language/run.bash go:rust",
+    "integration:go:cpp": "bash ./integration/cross-language/run.bash go:cpp",
+    "integration:ts:rust": "bash ./integration/cross-language/run.bash ts:rust",
+    "integration:ts:cpp": "bash ./integration/cross-language/run.bash ts:cpp",
+    "integration:rust:cpp": "bash ./integration/cross-language/run.bash rust:cpp",
     "lint": "bun run lint:go && bun run lint:js",
     "lint:go": "bun run go:aptre -- lint",
     "lint:js": "ESLINT_USE_FLAT_CONFIG=false eslint -c .eslintrc.cjs --ignore-pattern *.js --ignore-pattern *.d.ts ./",

package/srpc/client-invoker.go

@@ -69,7 +69,7 @@ func proxyStreamTo(src, dst Stream, errCh chan error) {
 	if rerr == nil && srcErr != nil {
 		rerr = srcErr
 	}
-	if rerr != nil {
+	if rerr != nil && rerr != io.EOF {
 		if errCh != nil {
 			errCh <- rerr
 		}

package/srpc/lib.rs

@@ -66,6 +66,7 @@ pub mod mux;
 pub mod packet;
 pub mod proto;
 pub mod rpc;
+#[path = "../rpcstream/mod.rs"]
 pub mod rpcstream;
 pub mod server;
 pub mod stream;

package/srpc/rpcstream/mod.rs

@@ -1,38 +0,0 @@
-//! RpcStream module for nested RPC calls.
-//!
-//! This module enables nesting RPC calls within RPC calls, supporting
-//! component-based architectures where different components expose different
-//! services via sub-streams.
-//!
-//! # Overview
-//!
-//! The rpcstream protocol works as follows:
-//! 1. Client opens a bidirectional stream to the server
-//! 2. Client sends `RpcStreamInit` with the target component ID
-//! 3. Server looks up the component and sends `RpcAck`
-//! 4. Both sides exchange `RpcStreamPacket::Data` containing nested RPC packets
-//!
-//! # Example
-//!
-//! ```rust,ignore
-//! use starpc::rpcstream::{open_rpc_stream, RpcStreamGetter};
-//!
-//! // Client side: open a stream to a component
-//! let stream = my_service.rpc_stream().await?;
-//! let rpc_stream = open_rpc_stream(stream, "my-component", true).await?;
-//!
-//! // Server side: handle incoming rpc stream
-//! let getter: RpcStreamGetter = Arc::new(|ctx, component_id, released| {
-//!     // Look up the invoker for this component
-//!     Some((invoker, release_fn))
-//! });
-//! handle_rpc_stream(stream, getter).await?;
-//! ```
-
-mod proto;
-mod stream;
-mod writer;
-
-pub use proto::*;
-pub use stream::*;
-pub use writer::*;