tokmon 0.23.5 → 0.24.0

package/dist/chunk-45ZP755H.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+import {
+  TOKMON_WS_METHODS,
+  TOKMON_WS_PATH,
+  TokmonRpcGroup
+} from "./chunk-O27I2XFN.js";
+
+// src/client/daemon-rpc-client.ts
+import { Cause, Context, Duration, Effect, Exit, Fiber, Layer, ManagedRuntime, Schedule, Stream } from "effect";
+import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
+import * as Socket from "effect/unstable/socket/Socket";
+var TokmonRpcClient = class extends Context.Service()(
+  "tokmon/client/DaemonRpcClient/TokmonRpcClient"
+) {
+};
+var dynamicImport = new Function("specifier", "return import(specifier)");
+function toWsUrl(baseUrl) {
+  const base = typeof window === "undefined" ? void 0 : window.location.origin;
+  const url = new URL(baseUrl, base);
+  if (url.protocol === "http:") url.protocol = "ws:";
+  else if (url.protocol === "https:") url.protocol = "wss:";
+  if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+    throw new Error(`unsupported daemon RPC protocol: ${url.protocol}`);
+  }
+  url.hash = "";
+  url.searchParams.delete("tokmonToken");
+  url.searchParams.delete("wsToken");
+  url.pathname = TOKMON_WS_PATH;
+  return url.toString();
+}
+function shouldUseNodeTransport(transport) {
+  if (transport === "node") return true;
+  if (transport === "browser") return false;
+  return typeof window === "undefined";
+}
+async function socketLayerFor(url, transport) {
+  if (shouldUseNodeTransport(transport)) {
+    const NodeSocket = await dynamicImport("@effect/platform-node/NodeSocket");
+    return NodeSocket.layerWebSocket(url);
+  }
+  return Socket.layerWebSocket(url).pipe(
+    Layer.provide(Socket.layerWebSocketConstructorGlobal)
+  );
+}
+function retryPolicy(options) {
+  const baseDelay = options.reconnectBaseDelayMs ?? 250;
+  const policy = Schedule.exponential(Duration.millis(baseDelay), 1.5).pipe(
+    Schedule.either(Schedule.spaced(Duration.millis(2500)))
+  );
+  return typeof options.reconnectAttempts === "number" ? policy.pipe(Schedule.both(Schedule.recurs(options.reconnectAttempts))) : policy;
+}
+function createDaemonRpcClient(baseUrl, options = {}) {
+  const url = toWsUrl(baseUrl);
+  const fibers = /* @__PURE__ */ new Set();
+  let session = null;
+  let sessionPromise = null;
+  let closed = false;
+  const setConn = (state, error) => {
+    options.onConn?.(state, error);
+  };
+  const resetSession = (active) => {
+    if (active !== void 0 && active !== null && active !== session) {
+      void active.runtime.dispose().catch(() => {
+      });
+      return;
+    }
+    const dead = active ?? session;
+    session = null;
+    sessionPromise = null;
+    if (dead) void dead.runtime.dispose().catch(() => {
+    });
+  };
+  const makeProtocolLayer = async () => {
+    const socketLayer = await socketLayerFor(url, options.transport);
+    const connectionHooksLayer = Layer.succeed(
+      RpcClient.ConnectionHooks,
+      RpcClient.ConnectionHooks.of({
+        onConnect: Effect.sync(() => {
+          setConn("live");
+        }),
+        onDisconnect: Effect.sync(() => {
+          if (!closed) {
+            setConn("reconnecting");
+          }
+        })
+      })
+    );
+    return Layer.effect(
+      RpcClient.Protocol,
+      RpcClient.makeProtocolSocket({
+        retryPolicy: retryPolicy(options),
+        retryTransientErrors: true
+      })
+    ).pipe(
+      Layer.provide(Layer.mergeAll(socketLayer, RpcSerialization.layerJson, connectionHooksLayer))
+    );
+  };
+  const ensureSession = async () => {
+    if (closed) throw new Error("daemon RPC client is closed");
+    if (session) return session;
+    if (sessionPromise) return sessionPromise;
+    setConn("connecting");
+    sessionPromise = (async () => {
+      let runtime;
+      try {
+        const protocolLayer = await makeProtocolLayer();
+        const clientLayer = Layer.effect(
+          TokmonRpcClient,
+          RpcClient.make(TokmonRpcGroup)
+        ).pipe(
+          Layer.provide(protocolLayer)
+        );
+        runtime = ManagedRuntime.make(clientLayer);
+        await runtime.runPromise(TokmonRpcClient.asEffect());
+        if (closed) {
+          await runtime.dispose();
+          throw new Error("daemon RPC client is closed");
+        }
+        session = { runtime };
+        return session;
+      } catch (error) {
+        sessionPromise = null;
+        await runtime?.dispose().catch(() => {
+        });
+        if (!closed) setConn("error", error);
+        throw error;
+      }
+    })();
+    return sessionPromise;
+  };
+  const run = async (effectFor) => {
+    const active = await ensureSession();
+    try {
+      return await active.runtime.runPromise(
+        TokmonRpcClient.use((client) => effectFor(client))
+      );
+    } catch (error) {
+      if (!closed) {
+        resetSession(active);
+        setConn("error", error);
+      }
+      throw error;
+    }
+  };
+  const subscribe = (streamFor, onValue, staleAfterFor) => {
+    if (closed) return () => {
+    };
+    let fiber = null;
+    let unsubscribed = false;
+    let retryTimer = null;
+    let watchdogTimer = null;
+    let lastValueAt = 0;
+    let staleAfterMs = Number.POSITIVE_INFINITY;
+    let watchdogRestart = false;
+    const stopFiber = () => {
+      if (!fiber) return;
+      const current = fiber;
+      fiber = null;
+      fibers.delete(current);
+      void (session?.runtime.runPromise(Fiber.interrupt(current)) ?? Effect.runPromise(Fiber.interrupt(current))).catch(() => {
+      });
+    };
+    const scheduleRetry = () => {
+      if (closed || unsubscribed || retryTimer) return;
+      retryTimer = setTimeout(() => {
+        retryTimer = null;
+        start();
+      }, options.reconnectBaseDelayMs ?? 250);
+      retryTimer.unref?.();
+    };
+    if (staleAfterFor) {
+      const checkEveryMs = Math.min(5e3, Math.max(10, (options.snapshotStaleFloorMs ?? 9e4) / 2));
+      watchdogTimer = setInterval(() => {
+        if (!fiber || lastValueAt === 0 || Date.now() - lastValueAt <= staleAfterMs) return;
+        watchdogRestart = true;
+        lastValueAt = Date.now();
+        setConn("reconnecting");
+        stopFiber();
+      }, checkEveryMs);
+      watchdogTimer.unref?.();
+    }
+    const start = () => {
+      void (async () => {
+        try {
+          const active = await ensureSession();
+          if (closed || unsubscribed) return;
+          lastValueAt = Date.now();
+          staleAfterMs = options.snapshotStaleFloorMs ?? 9e4;
+          const currentFiber = active.runtime.runFork(
+            TokmonRpcClient.use(
+              (client) => streamFor(client).pipe(
+                Stream.runForEach(
+                  (value) => Effect.sync(() => {
+                    lastValueAt = Date.now();
+                    if (staleAfterFor) staleAfterMs = staleAfterFor(value);
+                    try {
+                      onValue(value);
+                    } catch {
+                    }
+                  })
+                )
+              )
+            )
+          );
+          fiber = currentFiber;
+          fibers.add(currentFiber);
+          currentFiber.addObserver((exit) => {
+            fibers.delete(currentFiber);
+            if (fiber === currentFiber) fiber = null;
+            if (closed || unsubscribed) return;
+            const stale = watchdogRestart;
+            watchdogRestart = false;
+            resetSession(active);
+            if (stale || Exit.isSuccess(exit)) setConn("reconnecting");
+            else setConn("error", Cause.squash(exit.cause));
+            scheduleRetry();
+          });
+        } catch (error) {
+          if (!closed && !unsubscribed) {
+            resetSession();
+            setConn("error", error);
+            scheduleRetry();
+          }
+        }
+      })();
+    };
+    start();
+    return () => {
+      unsubscribed = true;
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+        retryTimer = null;
+      }
+      if (watchdogTimer) {
+        clearInterval(watchdogTimer);
+        watchdogTimer = null;
+      }
+      stopFiber();
+    };
+  };
+  return {
+    getConfig: () => run((client) => client[TOKMON_WS_METHODS.getConfig]({})).then((state) => state),
+    setConfig: (config) => run((client) => client[TOKMON_WS_METHODS.setConfig](config)).then((state) => state),
+    refresh: (scope = "all") => run((client) => client[TOKMON_WS_METHODS.refresh]({ scope })),
+    browseFs: (path) => run((client) => client[TOKMON_WS_METHODS.browseFs]({ path })),
+    subscribeSnapshot: (onSnapshot) => subscribe(
+      (client) => client[TOKMON_WS_METHODS.snapshot]({}).pipe(Stream.map((value) => value)),
+      onSnapshot,
+      (snapshot) => Math.max(options.snapshotStaleFloorMs ?? 9e4, snapshot.intervalMs * 3)
+    ),
+    subscribeConfig: (onConfig) => subscribe((client) => client[TOKMON_WS_METHODS.config]({}).pipe(Stream.map((value) => value)), onConfig),
+    async close() {
+      if (closed) return;
+      closed = true;
+      setConn("closed");
+      const active = [...fibers];
+      fibers.clear();
+      const activeSession = session ?? await sessionPromise?.catch(() => null) ?? null;
+      await Promise.all(active.map(
+        (fiber) => (activeSession?.runtime.runPromise(Fiber.interrupt(fiber)) ?? Effect.runPromise(Fiber.interrupt(fiber))).catch(() => {
+        })
+      ));
+      session = null;
+      sessionPromise = null;
+      if (activeSession) {
+        await activeSession.runtime.dispose().catch(() => {
+        });
+      }
+    }
+  };
+}
+
+export {
+  createDaemonRpcClient
+};