tokmon 0.23.5 → 0.25.0

package/dist/{chunk-MJWFCDBB.js → chunk-IOIAXKW2.js}

@@ -6,6 +6,12 @@ import {
   sendJson,
   serveStatic
 } from "./chunk-SMPY52EV.js";
+import {
+  buildAccounts,
+  colorHex,
+  fetchPeak,
+  namedHex
+} from "./chunk-45YYP2FJ.js";
 import {
   PROVIDERS,
   TOKMON_CAPABILITIES,
@@ -13,14 +19,10 @@ import {
   TOKMON_WS_METHODS,
   TOKMON_WS_PATH,
   TokmonRpcGroup,
-  buildAccounts,
-  colorHex,
   detectProviders,
-  fetchPeak,
-  namedHex,
   resolveTimezone,
   withTimeout
-} from "./chunk-IELQ5EY3.js";
+} from "./chunk-INBZLHJQ.js";
 import {
   cacheDir,
   expandHome,
@@ -28,7 +30,7 @@ import {
   normalizeConfig,
   saveConfig,
   snapshotCacheFile
-} from "./chunk-5CWOJMAH.js";
+} from "./chunk-E2YXYU73.js";
 
 // src/web/server.ts
 import { createServer } from "http";
@@ -187,7 +189,7 @@ function deferred() {
   });
   return { promise, resolve, reject };
 }
-function createRefreshQueue(perform, skipAutomatic = () => false) {
+function createRefreshQueue(perform, skipAutomatic = () => false, options = {}) {
   let activePass = null;
   let activeResult = null;
   let queued = null;
@@ -224,6 +226,7 @@ function createRefreshQueue(perform, skipAutomatic = () => false) {
     if (stopped || !force && skipAutomatic()) return Promise.resolve();
     if (!activePass) return launch();
     if (!force) return activeResult.promise;
+    if (options.forceWhileActive === "join") return activeResult.promise;
     if (!queued) queued = deferred();
     return queued.promise;
   };
@@ -250,10 +253,21 @@ var IDLE_PAUSE_MS = 6e4;
 var SNAPSHOT_CACHE_THROTTLE_MS = 2e4;
 var REVEAL_THROTTLE_MS = 500;
 var FETCH_TIMEOUT_MS = 3e4;
-var ATTACH_BILLING_MAX_AGE_MS = 3e4;
-function billingNeedsCatchUp(accounts, updatedAt, now = Date.now(), maxAgeMs = ATTACH_BILLING_MAX_AGE_MS) {
+var DEFAULT_BILLING_STALE_MS = 5 * 6e4;
+function billingNeedsCatchUp(accounts, updatedAt, now = Date.now(), maxAgeMs = DEFAULT_BILLING_STALE_MS) {
   return accounts.some(({ account }) => now - (updatedAt.get(account.id) ?? 0) >= maxAgeMs);
 }
+async function forEachProviderSequentially(values, task) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const group = groups.get(value.account.providerId) ?? [];
+    group.push(value);
+    groups.set(value.account.providerId, group);
+  }
+  await Promise.all([...groups.values()].map(async (group) => {
+    for (const value of group) await task(value);
+  }));
+}
 function runInBackground(task) {
   void task.catch(() => {
   });
@@ -403,7 +417,14 @@ function createDataEngine(opts) {
         }
         reveal();
       };
-      if (opts2.concurrent) {
+      if (opts2.concurrent === "provider") {
+        await forEachProviderSequentially(opts2.accounts(), async (r) => {
+          const result = await fetchOne(r);
+          if (stopped || epoch !== configEpoch) return;
+          applyResult(result);
+        });
+        if (stopped || epoch !== configEpoch) return;
+      } else if (opts2.concurrent) {
         await Promise.all(opts2.accounts().map(async (r) => {
           const result = await fetchOne(r);
           if (stopped || epoch !== configEpoch) return;
@@ -421,7 +442,8 @@ function createDataEngine(opts) {
       rebuild();
       throwIfRefreshFailures(opts2.scope, failures);
     },
-    idle
+    idle,
+    { forceWhileActive: opts2.forceWhileActive }
   );
   const refreshSummary = makeRefreshLoop({
     scope: "summary",
@@ -452,8 +474,10 @@ function createDataEngine(opts) {
     },
     state: billingState,
     updatedAt: billingUpdatedAt,
-    concurrent: true
+    concurrent: "provider",
+    forceWhileActive: "join"
   });
+  const refreshBillingIfStale = () => billingNeedsCatchUp(billingAccounts, billingUpdatedAt, Date.now(), billingIntervalMs) ? refreshBilling.run(true) : Promise.resolve();
   const refreshPeak = createRefreshQueue(
     async () => {
       if (stopped || !hasClaude) return;
@@ -547,7 +571,7 @@ function createDataEngine(opts) {
       rebuild();
       runInBackground(refreshSummary.run(true));
       runInBackground(refreshTable.run(true));
-      runInBackground(refreshBilling.run(true));
+      runInBackground(refreshBillingIfStale());
       if (hasClaude) runInBackground(refreshPeak.run(true));
       startTimers();
     },
@@ -574,9 +598,7 @@ function createDataEngine(opts) {
         runInBackground(refreshSummary.run(true));
         runInBackground(refreshTable.run(true));
       }
-      if (billingNeedsCatchUp(billingAccounts, billingUpdatedAt)) {
-        runInBackground(refreshBilling.run());
-      }
+      runInBackground(refreshBillingIfStale());
       return () => {
         snapshotSubscribers.delete(onSnapshot);
       };

package/dist/{chunk-3TJVFKXV.js → chunk-QM5E5RJZ.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   cacheDir
-} from "./chunk-5CWOJMAH.js";
+} from "./chunk-E2YXYU73.js";
 
 // src/web/lockfile.ts
 import { closeSync, fchmodSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";

package/dist/chunk-QUGH2XA6.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+import {
+  TOKMON_WS_METHODS,
+  TOKMON_WS_PATH,
+  TokmonRpcGroup
+} from "./chunk-INBZLHJQ.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
+};