@opentunnel/client 0.0.0 → 0.1.1

package/src/promise/client.ts

@@ -0,0 +1,120 @@
+import { Effect, Exit, ManagedRuntime, Scope, Stream } from "effect";
+import {
+  OpenTunnelClient,
+  type OpenTunnelClientOptions as EffectClientOptions,
+} from "../effect/client.js";
+import type {
+  OpenTunnelClientEvent,
+  OpenTunnelConnectOptions,
+  OpenTunnelIdentity,
+  OpenTunnelPendingIdentity,
+  OpenTunnelProfileOptions,
+  OpenTunnelProvisionStage,
+  OpenTunnelRoutes,
+  OpenTunnelStatus,
+  OpenTunnelStoredTunnel,
+} from "../effect/types.js";
+import { toEffectStorage, type OpenTunnelStorage } from "./storage.js";
+
+export interface OpenTunnelClientOptions {
+  readonly api?: URL | string;
+  readonly store?: OpenTunnelStorage;
+}
+
+export interface OpenTunnelConnection {
+  readonly tunnel: OpenTunnelIdentity;
+  readonly events: AsyncIterable<OpenTunnelClientEvent>;
+  readonly status: () => OpenTunnelStatus;
+  /**
+   * Replaces the routes. Changing only targets applies immediately; adding or
+   * removing names re-attaches the bridge.
+   */
+  readonly setRoutes: (routes: OpenTunnelRoutes) => Promise<void>;
+  /** Settles when the tunnel stops after a fatal error or is closed. */
+  readonly closed: Promise<void>;
+  readonly close: () => Promise<void>;
+}
+
+export interface OpenTunnelPromiseClient {
+  readonly profile: {
+    readonly list: () => Promise<ReadonlyArray<string>>;
+  };
+  readonly tunnel: {
+    readonly list: () => Promise<ReadonlyArray<OpenTunnelStoredTunnel>>;
+    readonly get: (options?: OpenTunnelProfileOptions) => Promise<OpenTunnelIdentity | undefined>;
+    readonly pending: (
+      options?: OpenTunnelProfileOptions,
+    ) => Promise<Pick<OpenTunnelPendingIdentity, "id" | "hostname"> | undefined>;
+    readonly resume: (
+      options?: OpenTunnelProfileOptions & {
+        readonly onProgress?: (stage: OpenTunnelProvisionStage) => void;
+      },
+    ) => Promise<OpenTunnelIdentity | undefined>;
+    readonly create: (
+      options?: OpenTunnelProfileOptions & {
+        readonly onProgress?: (stage: OpenTunnelProvisionStage) => void;
+      },
+    ) => Promise<OpenTunnelIdentity>;
+    readonly ensure: (
+      options?: OpenTunnelProfileOptions,
+    ) => Promise<OpenTunnelIdentity>;
+    readonly remove: (options?: OpenTunnelProfileOptions) => Promise<void>;
+    /**
+     * Starts forwarding routes for the profile's tunnel, creating it if
+     * needed. Resolves once the bridge first attaches; reconnects until closed.
+     */
+    readonly connect: (
+      options: OpenTunnelConnectOptions & { readonly signal?: AbortSignal },
+    ) => Promise<OpenTunnelConnection>;
+  };
+  readonly dispose: () => Promise<void>;
+}
+
+export function create(options: OpenTunnelClientOptions = {}): OpenTunnelPromiseClient {
+  const effectOptions: EffectClientOptions = {
+    api: options.api,
+    ...(options.store ? { storage: toEffectStorage(options.store) } : {}),
+  };
+  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));
+
+  return {
+    profile: { list: () => withClient((client) => client.profile.list()) },
+    tunnel: {
+      list: () => withClient((client) => client.tunnel.list()),
+      get: (input) => withClient((client) => client.tunnel.get(input)),
+      pending: (input) => withClient((client) => client.tunnel.pending(input)),
+      resume: (input) => withClient((client) => client.tunnel.resume(input)),
+      create: (input) => withClient((client) => client.tunnel.create(input)),
+      ensure: (input) => withClient((client) => client.tunnel.ensure(input)),
+      remove: (input) => withClient((client) => client.tunnel.remove(input)),
+      connect: async (input) => {
+        const scope = await runtime.runPromise(Scope.make());
+        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.provideService(Scope.Scope, scope),
+            ),
+          )
+          .catch(async (error) => {
+            await closeScope();
+            throw error;
+          });
+        const close = () => runtime.runPromise(connection.close).finally(closeScope);
+        input.signal?.addEventListener("abort", () => void close(), { once: true });
+        return {
+          tunnel: connection.tunnel,
+          events: Stream.toAsyncIterable(connection.events),
+          status: () => runtime.runSync(connection.status),
+          setRoutes: (routes) => runtime.runPromise(connection.setRoutes(routes)),
+          closed: runtime.runPromise(connection.closed).finally(closeScope),
+          close,
+        };
+      },
+    },
+    dispose: () => runtime.dispose(),
+  };
+}

package/src/promise/index.ts

@@ -0,0 +1,14 @@
+export * from "./client.js";
+export * from "./storage.js";
+export { OpenTunnelAttachError } from "../effect/tunnel.js";
+export type {
+  OpenTunnelClientEvent,
+  OpenTunnelConnectOptions,
+  OpenTunnelIdentity,
+  OpenTunnelPendingIdentity,
+  OpenTunnelProfileOptions,
+  OpenTunnelProvisionStage,
+  OpenTunnelRoutes,
+  OpenTunnelStatus,
+  OpenTunnelStoredTunnel,
+} from "../effect/types.js";

package/src/promise/storage.ts

@@ -0,0 +1,54 @@
+import { Effect } from "effect";
+import {
+  OpenTunnelStorage as EffectStorage,
+  type OpenTunnelStorage as EffectStorageType,
+} from "../effect/storage.js";
+import type {
+  OpenTunnelIdentity,
+  OpenTunnelPendingIdentity,
+  OpenTunnelStoredTunnel,
+} from "../effect/types.js";
+
+const EffectStorageSymbol = Symbol.for("@opentunnel/client/EffectStorage");
+
+export interface OpenTunnelStorage {
+  readonly profiles: () => Promise<ReadonlyArray<string>>;
+  readonly load: (profile: string) => Promise<OpenTunnelIdentity | undefined>;
+  readonly save: (profile: string, tunnel: OpenTunnelIdentity) => Promise<void>;
+  readonly loadPending: (profile: string) => Promise<OpenTunnelPendingIdentity | undefined>;
+  readonly savePending: (profile: string, tunnel: OpenTunnelPendingIdentity) => Promise<void>;
+  readonly remove: (profile: string) => Promise<void>;
+  readonly list: () => Promise<ReadonlyArray<OpenTunnelStoredTunnel>>;
+}
+
+type WrappedStorage = OpenTunnelStorage & { readonly [EffectStorageSymbol]: EffectStorageType };
+
+const wrap = (storage: EffectStorageType): WrappedStorage => ({
+  [EffectStorageSymbol]: storage,
+  profiles: () => Effect.runPromise(storage.profiles()),
+  load: (profile) => Effect.runPromise(storage.load(profile)),
+  save: (profile, tunnel) => Effect.runPromise(storage.save(profile, tunnel)),
+  loadPending: (profile) => Effect.runPromise(storage.loadPending(profile)),
+  savePending: (profile, tunnel) => Effect.runPromise(storage.savePending(profile, tunnel)),
+  remove: (profile) => Effect.runPromise(storage.remove(profile)),
+  list: () => Effect.runPromise(storage.list()),
+});
+
+export const OpenTunnelStorage = {
+  memory: (): OpenTunnelStorage => wrap(EffectStorage.memory()),
+  xdg: (options?: { readonly env?: NodeJS.ProcessEnv; readonly home?: string }): OpenTunnelStorage =>
+    wrap(EffectStorage.xdg(options)),
+};
+
+export function toEffectStorage(storage: OpenTunnelStorage): EffectStorageType {
+  if (EffectStorageSymbol in storage) return (storage as WrappedStorage)[EffectStorageSymbol];
+  return {
+    profiles: () => Effect.tryPromise(() => storage.profiles()),
+    load: (profile) => Effect.tryPromise(() => storage.load(profile)),
+    save: (profile, tunnel) => Effect.tryPromise(() => storage.save(profile, tunnel)),
+    loadPending: (profile) => Effect.tryPromise(() => storage.loadPending(profile)),
+    savePending: (profile, tunnel) => Effect.tryPromise(() => storage.savePending(profile, tunnel)),
+    remove: (profile) => Effect.tryPromise(() => storage.remove(profile)),
+    list: () => Effect.tryPromise(() => storage.list()),
+  };
+}