@opentunnel/client 0.1.1 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentunnel/client",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "OpenTunnel SDK for Bun: expose local services through a blind TLS tunnel",
   "license": "MIT",
   "repository": {
@@ -28,8 +28,8 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@opentunnel/protocol": "0.1.0",
-    "effect": "4.0.0-beta.42"
+    "@opentunnel/protocol": "0.2.0",
+    "effect": "4.0.0-rc.112"
   },
   "devDependencies": {
     "@peculiar/x509": "2.0.0",

package/src/effect/api.ts

@@ -1,9 +1,13 @@
-import { Effect, Layer, ServiceMap } from "effect";
+import { Effect, Layer, Context } from "effect";
 import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";
+import pkg from "../../package.json" with { type: "json" };
 import { HttpApiClient } from "effect/unstable/httpapi";
 import { Api } from "@opentunnel/protocol/api/api";
 import { Tunnel } from "@opentunnel/protocol/tunnel";
 
+/** How the SDK identifies itself to the server, on API calls and the bridge. */
+export const USER_AGENT = `opentunnel-sdk/${pkg.version}`;
+
 type Client = HttpApiClient.ForApi<typeof Api>;
 
 interface OpenTunnelApi {
@@ -11,14 +15,16 @@ interface OpenTunnelApi {
   readonly authorized: (token: Tunnel.Token) => Effect.Effect<Client>;
 }
 
-export class OpenTunnelApiClient extends ServiceMap.Service<OpenTunnelApiClient, OpenTunnelApi>()(
+export class OpenTunnelApiClient extends Context.Service<OpenTunnelApiClient, OpenTunnelApi>()(
   "@opentunnel/client/OpenTunnelApiClient",
 ) {
   static layer(options: { readonly api: URL | string }) {
     return Layer.effect(
       OpenTunnelApiClient,
       Effect.gen(function* () {
-        const httpClient = yield* HttpClient.HttpClient;
+        const httpClient = (yield* HttpClient.HttpClient).pipe(
+          HttpClient.mapRequest(HttpClientRequest.setHeader("user-agent", USER_AGENT)),
+        );
         const client = yield* HttpApiClient.makeWith(Api, {
           baseUrl: options.api,
           httpClient,

package/src/effect/client.ts

@@ -1,4 +1,4 @@
-import { Cause, Effect, Layer, Queue, ServiceMap, Stream } from "effect";
+import { Cause, Effect, Layer, Queue, Context, Stream } from "effect";
 import { CSR } from "@opentunnel/protocol/csr";
 import { Tunnel } from "@opentunnel/protocol/tunnel";
 import { OpenTunnelApiClient } from "./api.js";
@@ -33,7 +33,7 @@ export interface OpenTunnelClientOptions {
   readonly storage?: Storage;
 }
 
-export class OpenTunnelClient extends ServiceMap.Service<
+export class OpenTunnelClient extends Context.Service<
   OpenTunnelClient,
   OpenTunnelEffectClient
 >()("@opentunnel/client/OpenTunnelClient") {
@@ -56,10 +56,10 @@ export class OpenTunnelClient extends ServiceMap.Service<
           readonly pending: OpenTunnelPendingIdentity;
           readonly onProgress?: (stage: OpenTunnelProvisionStage) => void;
         }) {
-          const authorized = yield* api.authorized(Tunnel.Token.makeUnsafe(options.pending.token));
+          const authorized = yield* api.authorized(Tunnel.Token.make(options.pending.token));
           yield* Effect.sync(() => options.onProgress?.("requesting-certificate"));
           yield* authorized.tunnel["tunnel.bindCertificate"]({
-            params: { id: Tunnel.ID.makeUnsafe(options.pending.id) },
+            params: { id: Tunnel.ID.make(options.pending.id) },
             payload: { csr: options.pending.csr as CSR.Raw },
           }).pipe(
             // A resumed provision may already have an issuance in flight.
@@ -71,7 +71,7 @@ export class OpenTunnelClient extends ServiceMap.Service<
             while (true) {
               yield* Effect.sync(() => options.onProgress?.("waiting-certificate"));
               const value = yield* authorized.tunnel["tunnel.getCertificate"]({
-                params: { id: Tunnel.ID.makeUnsafe(options.pending.id) },
+                params: { id: Tunnel.ID.make(options.pending.id) },
               }).pipe(
                 Effect.mapError((cause) => clientError("Failed to read certificate", cause)),
               );
@@ -176,9 +176,9 @@ export class OpenTunnelClient extends ServiceMap.Service<
         ) {
           const existing = yield* get(input);
           if (!existing) return yield* create(input);
-          const authorized = yield* api.authorized(Tunnel.Token.makeUnsafe(existing.token));
+          const authorized = yield* api.authorized(Tunnel.Token.make(existing.token));
           const certificate = yield* authorized.tunnel["tunnel.getCertificate"]({
-            params: { id: Tunnel.ID.makeUnsafe(existing.id) },
+            params: { id: Tunnel.ID.make(existing.id) },
           }).pipe(
             Effect.mapError((cause) => clientError("Failed to read certificate", cause)),
           );
@@ -197,9 +197,9 @@ export class OpenTunnelClient extends ServiceMap.Service<
           if (state.type !== "failed") return existing;
           return yield* provision({
             profile: profileName(input),
-            id: Tunnel.ID.makeUnsafe(existing.id),
+            id: Tunnel.ID.make(existing.id),
             hostname: existing.hostname,
-            token: Tunnel.Token.makeUnsafe(existing.token),
+            token: Tunnel.Token.make(existing.token),
           });
         });
 
@@ -235,9 +235,9 @@ export class OpenTunnelClient extends ServiceMap.Service<
               const profile = profileName(input);
               const identity = yield* storage.load(profile);
               if (!identity) return;
-              const authorized = yield* api.authorized(Tunnel.Token.makeUnsafe(identity.token));
+              const authorized = yield* api.authorized(Tunnel.Token.make(identity.token));
               yield* authorized.tunnel["tunnel.remove"]({
-                params: { id: Tunnel.ID.makeUnsafe(identity.id) },
+                params: { id: Tunnel.ID.make(identity.id) },
               }).pipe(
                 Effect.mapError((cause) => clientError("Failed to remove tunnel", cause)),
               );

package/src/effect/errors.ts

@@ -1,13 +1,13 @@
 import { Schema } from "effect";
 
-export class OpenTunnelClientError extends Schema.TaggedErrorClass<OpenTunnelClientError>()(
+export class OpenTunnelClientError extends Schema.TaggedError<OpenTunnelClientError>()(
   "OpenTunnelClientError",
-  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+  { message: Schema.String, cause: Schema.optional(Schema.Defect()) },
 ) {}
 
-export class OpenTunnelStorageError extends Schema.TaggedErrorClass<OpenTunnelStorageError>()(
+export class OpenTunnelStorageError extends Schema.TaggedError<OpenTunnelStorageError>()(
   "OpenTunnelStorageError",
-  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+  { message: Schema.String, cause: Schema.optional(Schema.Defect()) },
 ) {}
 
 export type OpenTunnelError = OpenTunnelClientError | OpenTunnelStorageError;

package/src/effect/tunnel.ts

@@ -4,6 +4,13 @@ import { Duplex } from "node:stream";
 import * as Tls from "node:tls";
 import { BridgeProtocol } from "@opentunnel/protocol/bridge-protocol";
 import { Names } from "@opentunnel/protocol/names";
+import { USER_AGENT } from "./api.js";
+
+/** Bun's WebSocket also takes options with request headers, which the DOM typings don't know about. */
+const BunWebSocket = WebSocket as unknown as new (
+  url: URL,
+  options: { readonly protocols: string[]; readonly headers: Record<string, string> },
+) => WebSocket;
 import type {
   OpenTunnelClientEvent,
   OpenTunnelIdentity,
@@ -308,7 +315,10 @@ class Session {
         this.options.api,
       );
       url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-      const socket = new WebSocket(url, BridgeProtocol.WEBSOCKET_SUBPROTOCOL);
+      const socket = new BunWebSocket(url, {
+        protocols: [BridgeProtocol.WEBSOCKET_SUBPROTOCOL],
+        headers: { "user-agent": USER_AGENT },
+      });
       socket.binaryType = "arraybuffer";
       this.socket = socket;
       this.attachTimeout = setTimeout(

package/src/promise/client.ts

@@ -78,7 +78,7 @@ export function create(options: OpenTunnelClientOptions = {}): OpenTunnelPromise
   const runtime = ManagedRuntime.make(OpenTunnelClient.layer(effectOptions));
   const withClient = <A, E>(
     f: (client: OpenTunnelClient["Service"]) => Effect.Effect<A, E>,
-  ) => runtime.runPromise(Effect.flatMap(OpenTunnelClient.asEffect(), f));
+  ) => runtime.runPromise(Effect.flatMap(OpenTunnelClient, f));
 
   return {
     profile: { list: () => withClient((client) => client.profile.list()) },
@@ -95,7 +95,7 @@ export function create(options: OpenTunnelClientOptions = {}): OpenTunnelPromise
         const closeScope = () => runtime.runPromise(Scope.close(scope, Exit.void));
         const connection = await runtime
           .runPromise(
-            Effect.flatMap(OpenTunnelClient.asEffect(), (client) => client.tunnel.connect(input)).pipe(
+            Effect.flatMap(OpenTunnelClient, (client) => client.tunnel.connect(input)).pipe(
               Effect.provideService(Scope.Scope, scope),
             ),
           )