tokmon 0.28.1 → 0.28.3

package/dist/chunk-7CH6S7BR.js

@@ -0,0 +1,447 @@
+#!/usr/bin/env node
+import {
+  ConfigUpdateConflictFailure,
+  TOKMON_WS_METHODS,
+  TOKMON_WS_PATH,
+  TokmonRpcGroup
+} from "./chunk-JZSZEHVD.js";
+import {
+  normalizeConfig
+} from "./chunk-HNWEJ6MS.js";
+
+// src/client/daemon-rpc-client.ts
+import { Cause, Context, Duration, Effect, Exit, Fiber, Layer, ManagedRuntime, Schedule, Schema, Stream } from "effect";
+import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
+import { RpcClientError } from "effect/unstable/rpc/RpcClientError";
+import * as Socket from "effect/unstable/socket/Socket";
+var DaemonRpcConnectionError = class extends Error {
+  constructor(message = "daemon RPC connection closed") {
+    super(message);
+    this.name = "DaemonRpcConnectionError";
+  }
+};
+var DaemonRpcRequestTimeoutError = class extends Error {
+  constructor(method, timeoutMs) {
+    super(`${method} timed out after ${timeoutMs}ms`);
+    this.method = method;
+    this.timeoutMs = timeoutMs;
+    this.name = "DaemonRpcRequestTimeoutError";
+  }
+  method;
+  timeoutMs;
+};
+var TokmonRpcClient = class extends Context.Service()(
+  "tokmon/client/DaemonRpcClient/TokmonRpcClient"
+) {
+};
+var dynamicImport = new Function("specifier", "return import(specifier)");
+function makeSignal() {
+  let settled = false;
+  let resolvePromise;
+  const promise = new Promise((resolve) => {
+    resolvePromise = resolve;
+  });
+  return {
+    promise,
+    resolve: (value) => {
+      if (settled) return;
+      settled = true;
+      resolvePromise(value);
+    }
+  };
+}
+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, openTimeoutMs) {
+  const socketOptions = { openTimeout: Duration.millis(openTimeoutMs) };
+  if (shouldUseNodeTransport(transport)) {
+    const NodeSocket = await dynamicImport("@effect/platform-node/NodeSocket");
+    return NodeSocket.layerWebSocket(url, socketOptions);
+  }
+  return Socket.layerWebSocket(url, socketOptions).pipe(
+    Layer.provide(Socket.layerWebSocketConstructorGlobal)
+  );
+}
+function normalizeConfigState(state) {
+  return {
+    protocol: {
+      version: state.protocol.version,
+      capabilities: [...state.protocol.capabilities]
+    },
+    config: normalizeConfig(state.config)
+  };
+}
+function normalizeSnapshot(snapshot) {
+  const copyHeadroom = (headroom) => headroom ? {
+    ...headroom,
+    activeAccountIds: [...headroom.activeAccountIds],
+    factors: headroom.factors.map((factor) => ({ ...factor }))
+  } : void 0;
+  const copyRows = (rows) => rows.map((row) => ({
+    ...row,
+    models: [...row.models],
+    breakdown: row.breakdown.map((detail) => ({ ...detail }))
+  }));
+  return {
+    ...snapshot,
+    providers: snapshot.providers.map((provider) => ({
+      ...provider,
+      headroom: copyHeadroom(provider.headroom)
+    })),
+    accounts: snapshot.accounts.map((account) => ({
+      ...account,
+      identity: account.identity ? { ...account.identity } : void 0,
+      quotas: account.quotas?.map((quota) => ({ ...quota })),
+      headroom: copyHeadroom(account.headroom),
+      dashboard: account.dashboard ? {
+        ...account.dashboard,
+        today: { ...account.dashboard.today },
+        week: { ...account.dashboard.week },
+        month: { ...account.dashboard.month },
+        series: [...account.dashboard.series]
+      } : null,
+      table: account.table ? {
+        daily: copyRows(account.table.daily),
+        weekly: copyRows(account.table.weekly),
+        monthly: copyRows(account.table.monthly)
+      } : null,
+      billing: account.billing ? {
+        ...account.billing,
+        metrics: account.billing.metrics.map((metric) => ({
+          ...metric,
+          format: { ...metric.format }
+        })),
+        activity: account.billing.activity ? { ...account.billing.activity, series: [...account.billing.activity.series] } : account.billing.activity,
+        modelSpend: account.billing.modelSpend == null ? account.billing.modelSpend : account.billing.modelSpend.map((spend) => ({ ...spend }))
+      } : null,
+      summaryUpdatedAt: account.summaryUpdatedAt ?? null,
+      billingUpdatedAt: account.billingUpdatedAt ?? null,
+      tableUpdatedAt: account.tableUpdatedAt ?? null
+    })),
+    peak: snapshot.peak ? { ...snapshot.peak } : null
+  };
+}
+function normalizeRequestFailure(error) {
+  if (!error || typeof error !== "object" || error.kind !== "conflict") return error;
+  const state = error.state;
+  if (!state) return error;
+  const normalized = normalizeConfigState(state);
+  if (error instanceof ConfigUpdateConflictFailure) {
+    return new ConfigUpdateConflictFailure({ kind: "conflict", state: normalized });
+  }
+  return { ...error, state: normalized };
+}
+function isSessionFailure(error) {
+  return error instanceof RpcClientError || Schema.isSchemaError(error);
+}
+async function waitForReady(ready, disconnected, timeoutMs) {
+  let timer = null;
+  try {
+    await Promise.race([
+      ready.promise,
+      disconnected.promise.then((error) => Promise.reject(error)),
+      new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new DaemonRpcConnectionError(`daemon RPC connection timed out after ${timeoutMs}ms`)), timeoutMs);
+        timer.unref?.();
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function createDaemonRpcClient(baseUrl, options = {}) {
+  const url = toWsUrl(baseUrl);
+  const requestTimeoutMs = Math.max(1, options.requestTimeoutMs ?? 3e4);
+  const reconnectBaseDelayMs = Math.max(1, options.reconnectBaseDelayMs ?? 250);
+  const subscriptions = /* @__PURE__ */ new Set();
+  let session = null;
+  let sessionPromise = null;
+  let pendingRuntime = null;
+  let supervisorPromise = null;
+  let reconnectTimer = null;
+  let reconnectAttemptsUsed = 0;
+  let hasConnected = false;
+  let closed = false;
+  const reportSubscriberError = (error) => {
+    if (options.onSubscriberError) {
+      try {
+        options.onSubscriberError(error);
+      } catch (reportError) {
+        console.error("[tokmon] daemon RPC subscriber error reporter failed", reportError);
+      }
+      return;
+    }
+    console.error("[tokmon] daemon RPC subscriber failed", error);
+  };
+  const setConn = (state, error) => {
+    try {
+      options.onConn?.(state, error);
+    } catch (callbackError) {
+      reportSubscriberError(callbackError);
+    }
+  };
+  const clearReconnectTimer = () => {
+    if (!reconnectTimer) return;
+    clearTimeout(reconnectTimer);
+    reconnectTimer = null;
+  };
+  const stopSubscriptionFiber = (subscription) => {
+    const fiber = subscription.fiber;
+    subscription.fiber = null;
+    subscription.owner = null;
+    return fiber ? Effect.runPromise(Fiber.interrupt(fiber)).catch(() => {
+    }) : Promise.resolve();
+  };
+  const disposeSubscription = (subscription) => {
+    subscription.active = false;
+    subscriptions.delete(subscription);
+    if (subscription.watchdogTimer) {
+      clearInterval(subscription.watchdogTimer);
+      subscription.watchdogTimer = null;
+    }
+    return stopSubscriptionFiber(subscription);
+  };
+  const scheduleReconnect = () => {
+    if (closed || subscriptions.size === 0 || reconnectTimer || session || sessionPromise) return;
+    if (typeof options.reconnectAttempts === "number" && reconnectAttemptsUsed >= options.reconnectAttempts) return;
+    const delayMs = Math.min(2500, reconnectBaseDelayMs * 1.5 ** reconnectAttemptsUsed);
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      reconnectAttemptsUsed++;
+      connectSubscriptions();
+    }, delayMs);
+    reconnectTimer.unref?.();
+  };
+  const invalidateSession = (active, state, error) => {
+    if (active.invalidated) return;
+    active.invalidated = true;
+    if (session === active) session = null;
+    void active.runtime.dispose().catch(() => {
+    });
+    if (!closed) setConn(state, error);
+    scheduleReconnect();
+  };
+  const makeProtocolLayer = async (ready, disconnected) => {
+    const socketLayer = await socketLayerFor(url, options.transport, requestTimeoutMs);
+    const connectionHooksLayer = Layer.succeed(
+      RpcClient.ConnectionHooks,
+      RpcClient.ConnectionHooks.of({
+        onConnect: Effect.sync(() => {
+          ready.resolve();
+        }),
+        onDisconnect: Effect.sync(() => {
+          disconnected.resolve(new DaemonRpcConnectionError());
+        })
+      })
+    );
+    return Layer.effect(
+      RpcClient.Protocol,
+      RpcClient.makeProtocolSocket({
+        retryPolicy: Schedule.recurs(0),
+        retryTransientErrors: false
+      })
+    ).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(hasConnected ? "reconnecting" : "connecting");
+    const pending = (async () => {
+      let runtime = null;
+      try {
+        const ready = makeSignal();
+        const disconnected = makeSignal();
+        const protocolLayer = await makeProtocolLayer(ready, disconnected);
+        const clientLayer = Layer.effect(
+          TokmonRpcClient,
+          RpcClient.make(TokmonRpcGroup)
+        ).pipe(Layer.provide(protocolLayer));
+        runtime = ManagedRuntime.make(clientLayer);
+        pendingRuntime = runtime;
+        await runtime.runPromise(TokmonRpcClient.asEffect());
+        await waitForReady(ready, disconnected, requestTimeoutMs);
+        if (closed) throw new Error("daemon RPC client is closed");
+        const active = {
+          runtime,
+          disconnected: disconnected.promise,
+          invalidated: false
+        };
+        session = active;
+        pendingRuntime = null;
+        hasConnected = true;
+        reconnectAttemptsUsed = 0;
+        setConn("live");
+        void active.disconnected.then((error) => {
+          invalidateSession(active, "reconnecting", error);
+        });
+        startAllSubscriptions(active);
+        return active;
+      } catch (error) {
+        if (pendingRuntime === runtime) pendingRuntime = null;
+        await runtime?.dispose().catch(() => {
+        });
+        if (!closed) setConn("error", error);
+        throw error;
+      }
+    })();
+    sessionPromise = pending;
+    try {
+      return await pending;
+    } finally {
+      if (sessionPromise === pending) sessionPromise = null;
+    }
+  };
+  const run = async (method, effectFor) => {
+    const active = await ensureSession();
+    try {
+      return await active.runtime.runPromise(
+        TokmonRpcClient.use((client) => effectFor(client)).pipe(
+          Effect.timeoutOrElse({
+            duration: Duration.millis(requestTimeoutMs),
+            orElse: () => Effect.fail(new DaemonRpcRequestTimeoutError(method, requestTimeoutMs))
+          })
+        )
+      );
+    } catch (rawError) {
+      const error = normalizeRequestFailure(rawError);
+      if (!closed && isSessionFailure(error)) invalidateSession(active, "error", error);
+      throw error;
+    }
+  };
+  const startSubscription = (subscription, active) => {
+    if (closed || !subscription.active || subscription.fiber || active.invalidated) return;
+    subscription.lastValueAt = Date.now();
+    subscription.staleAfterMs = options.snapshotStaleFloorMs ?? 9e4;
+    subscription.owner = active;
+    const fiber = active.runtime.runFork(
+      TokmonRpcClient.use(
+        (client) => subscription.streamFor(client).pipe(
+          Stream.runForEach(
+            (value) => Effect.sync(() => {
+              subscription.lastValueAt = Date.now();
+              if (subscription.staleAfterFor) subscription.staleAfterMs = subscription.staleAfterFor(value);
+              try {
+                subscription.onValue(value);
+              } catch (error) {
+                reportSubscriberError(error);
+              }
+            })
+          )
+        )
+      )
+    );
+    subscription.fiber = fiber;
+    fiber.addObserver((exit) => {
+      if (subscription.fiber === fiber) subscription.fiber = null;
+      if (subscription.owner === active) subscription.owner = null;
+      if (closed || !subscription.active || active.invalidated) return;
+      if (Exit.isSuccess(exit)) {
+        invalidateSession(active, "reconnecting");
+      } else {
+        invalidateSession(active, "error", Cause.squash(exit.cause));
+      }
+    });
+  };
+  const startAllSubscriptions = (active) => {
+    for (const subscription of subscriptions) startSubscription(subscription, active);
+  };
+  function connectSubscriptions() {
+    if (closed || subscriptions.size === 0 || supervisorPromise) return;
+    supervisorPromise = ensureSession().then(() => void 0).catch(() => {
+      scheduleReconnect();
+    }).finally(() => {
+      supervisorPromise = null;
+    });
+  }
+  const subscribe = (streamFor, onValue, staleAfterFor) => {
+    if (closed) return () => {
+    };
+    const subscription = {
+      streamFor,
+      onValue,
+      staleAfterFor,
+      active: true,
+      fiber: null,
+      owner: null,
+      watchdogTimer: null,
+      lastValueAt: 0,
+      staleAfterMs: Number.POSITIVE_INFINITY
+    };
+    subscriptions.add(subscription);
+    if (staleAfterFor) {
+      const checkEveryMs = Math.min(5e3, Math.max(10, (options.snapshotStaleFloorMs ?? 9e4) / 2));
+      subscription.watchdogTimer = setInterval(() => {
+        if (!subscription.fiber || !subscription.owner || subscription.lastValueAt === 0) return;
+        if (Date.now() - subscription.lastValueAt <= subscription.staleAfterMs) return;
+        subscription.lastValueAt = Date.now();
+        invalidateSession(subscription.owner, "reconnecting");
+      }, checkEveryMs);
+      subscription.watchdogTimer.unref?.();
+    }
+    if (session) startSubscription(subscription, session);
+    else connectSubscriptions();
+    return () => {
+      void disposeSubscription(subscription);
+      if (subscriptions.size === 0) clearReconnectTimer();
+    };
+  };
+  return {
+    getConfig: () => run(TOKMON_WS_METHODS.getConfig, (client) => client[TOKMON_WS_METHODS.getConfig]({})).then(normalizeConfigState),
+    setConfig: (update) => run(TOKMON_WS_METHODS.setConfig, (client) => client[TOKMON_WS_METHODS.setConfig](update)).then(normalizeConfigState),
+    refresh: (scope = "all") => run(TOKMON_WS_METHODS.refresh, (client) => client[TOKMON_WS_METHODS.refresh]({ scope })),
+    browseFs: (path) => run(TOKMON_WS_METHODS.browseFs, (client) => client[TOKMON_WS_METHODS.browseFs]({ path })),
+    subscribeSnapshot: (onSnapshot) => subscribe(
+      (client) => client[TOKMON_WS_METHODS.snapshot]({}).pipe(Stream.map(normalizeSnapshot)),
+      onSnapshot,
+      (snapshot) => Math.max(options.snapshotStaleFloorMs ?? 9e4, snapshot.intervalMs * 3)
+    ),
+    subscribeConfig: (onConfig) => subscribe(
+      (client) => client[TOKMON_WS_METHODS.config]({}).pipe(Stream.map(normalizeConfigState)),
+      onConfig
+    ),
+    async close() {
+      if (closed) return;
+      closed = true;
+      setConn("closed");
+      clearReconnectTimer();
+      const cleanup = [...subscriptions].map(disposeSubscription);
+      subscriptions.clear();
+      const activeSession = session;
+      session = null;
+      await pendingRuntime?.dispose().catch(() => {
+      });
+      await Promise.all(cleanup);
+      await activeSession?.runtime.dispose().catch(() => {
+      });
+      await sessionPromise?.catch(() => {
+      });
+      pendingRuntime = null;
+      sessionPromise = null;
+      supervisorPromise = null;
+    }
+  };
+}
+
+export {
+  createDaemonRpcClient
+};