tokelytics 0.3.1 → 0.3.3

package/README.md

@@ -9,7 +9,7 @@ prompts or responses.
 
 ```
 npx tokelytics@latest login    # opens your browser to approve — no setup, no keys
-npx tokelytics@latest watch     # watches locally; cloud snapshot up to every 30m
+npx tokelytics@latest watch     # local live updates; cloud backup every 20m
 ```
 
 Keep `@latest` in install and onboarding commands. Agents older than 0.3.1

package/bin/tokelytics.mjs

@@ -1781,7 +1781,7 @@ var FirestoreSink = class {
 };
 
 // src/version.ts
-var AGENT_VERSION = "0.3.1";
+var AGENT_VERSION = "0.3.3";
 
 // src/sync.ts
 async function runSync(connectors, sink, state, device, limitCollectors = [], options = {}) {
@@ -1863,7 +1863,7 @@ async function runSync(connectors, sink, state, device, limitCollectors = [], op
     lastLocalEventAt: publication.lastLocalEventAt,
     lastCloudWriteAt: publication.lastCloudWriteAt
   };
-  if (publication.dashboardDirty && cloudWriteDue && hasBudget) {
+  if (publication.dashboardDirty && cloudWriteDue && hasBudget && !options.suppressCloudPublish) {
     try {
       dashboard.sync = {
         ...dashboard.sync,
@@ -1877,7 +1877,12 @@ async function runSync(connectors, sink, state, device, limitCollectors = [], op
       publication.dashboardDirty = false;
       published = true;
     } catch (error) {
-      dashboard.sync.localChangesPending = true;
+      dashboard.sync = {
+        ...dashboard.sync,
+        cloudWritesToday: publication.cloudWritesToday ?? 0,
+        localChangesPending: true,
+        lastCloudWriteAt: publication.lastCloudWriteAt
+      };
       publicationError = error;
     }
   }
@@ -1943,10 +1948,15 @@ async function createRunner() {
   });
   const sink = new FirestoreSink(rest, session.uid);
   return {
+    uid: session.uid,
     connectors,
     watchPaths() {
       return connectors.flatMap((c) => c.watchPaths());
     },
+    async localSnapshot() {
+      const state = await loadState();
+      return state.dashboard ? prepareDashboardSnapshotForCloud(state.dashboard) : void 0;
+    },
     async syncOnce(options = {}) {
       const state = await loadState();
       const device = {
@@ -1968,13 +1978,13 @@ async function createRunner() {
         publication: res.publication
       };
       if (!sameState(state, nextState)) await saveState(nextState);
-      if (res.publicationError) throw res.publicationError;
       return {
         processedTurns: res.processedTurns,
         processedLimits: res.processedLimits,
         byProvider: res.byProvider,
         published: res.published,
-        cloudWritesToday: res.publication.cloudWritesToday ?? 0
+        cloudWritesToday: res.publication.cloudWritesToday ?? 0,
+        publicationError: res.publicationError
       };
     }
   };
@@ -3690,16 +3700,99 @@ function watch(paths, options = {}) {
 }
 var esm_default = { watch, FSWatcher };
 
+// src/local-server.ts
+import { createServer as createServer2 } from "node:http";
+var LOCAL_DASHBOARD_PORT = 47821;
+var ALLOWED_ORIGINS = /* @__PURE__ */ new Set([
+  "https://tokelytics.web.app",
+  "https://tokelytics.firebaseapp.com",
+  "http://localhost:3000",
+  "http://127.0.0.1:3000"
+]);
+async function startLocalDashboardServer(getSnapshot, ownerUid, port = LOCAL_DASHBOARD_PORT) {
+  const server = createServer2(async (request, response) => {
+    const origin = request.headers.origin;
+    if (!origin || !ALLOWED_ORIGINS.has(origin)) {
+      response.writeHead(403, { "Content-Type": "application/json" });
+      response.end(JSON.stringify({ error: "Origin is not allowed." }));
+      return;
+    }
+    const corsHeaders = {
+      "Access-Control-Allow-Origin": origin,
+      "Access-Control-Allow-Methods": "GET, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type",
+      "Access-Control-Allow-Private-Network": "true",
+      "Cache-Control": "no-store",
+      Vary: "Origin, Access-Control-Request-Private-Network"
+    };
+    if (request.method === "OPTIONS") {
+      response.writeHead(204, corsHeaders);
+      response.end();
+      return;
+    }
+    const url = new URL(request.url ?? "/", "http://127.0.0.1");
+    if (request.method !== "GET" || url.pathname !== "/v1/snapshot" || url.searchParams.get("uid") !== ownerUid) {
+      response.writeHead(404, { ...corsHeaders, "Content-Type": "application/json" });
+      response.end(JSON.stringify({ error: "Not found." }));
+      return;
+    }
+    try {
+      const snapshot2 = await getSnapshot();
+      response.writeHead(200, { ...corsHeaders, "Content-Type": "application/json" });
+      response.end(
+        JSON.stringify({
+          service: "tokelytics",
+          version: 1,
+          servedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          snapshot: snapshot2 ?? null
+        })
+      );
+    } catch {
+      response.writeHead(503, { ...corsHeaders, "Content-Type": "application/json" });
+      response.end(JSON.stringify({ error: "Local snapshot is temporarily unavailable." }));
+    }
+  });
+  await listen(server, port);
+  const address = server.address();
+  const resolvedPort = typeof address === "object" && address ? address.port : port;
+  return {
+    port: resolvedPort,
+    close: () => close(server)
+  };
+}
+function listen(server, port) {
+  return new Promise((resolve4, reject) => {
+    const onError = (error) => reject(error);
+    server.once("error", onError);
+    server.listen(port, "127.0.0.1", () => {
+      server.off("error", onError);
+      resolve4();
+    });
+  });
+}
+function close(server) {
+  return new Promise((resolve4, reject) => {
+    server.close((error) => error ? reject(error) : resolve4());
+  });
+}
+
 // src/watch.ts
 var DEBOUNCE_MS = 1200;
 var LIMIT_REFRESH_MS = 6e4;
 var FALLBACK_SCAN_MS = 5e3;
 var DEVICE_HEARTBEAT_MS = 60 * 6e4;
-var CLOUD_SYNC_INTERVAL_MS = 30 * 6e4;
-var MAX_CLOUD_WRITES_PER_DAY = 16;
+var CLOUD_SYNC_INTERVAL_MS = 20 * 6e4;
+var MAX_CLOUD_WRITES_PER_DAY = 24;
 var QUOTA_RETRY_MS = 15 * 6e4;
 var QUOTA_RETRY_JITTER_MS = 5 * 6e4;
 async function watch2(runner) {
+  let localServer;
+  try {
+    localServer = await startLocalDashboardServer(() => runner.localSnapshot(), runner.uid);
+    console.log(`Local live dashboard ready on 127.0.0.1:${localServer.port}.`);
+  } catch (error) {
+    console.warn(`Local live dashboard unavailable: ${error.message}`);
+  }
   const startupRetryAfter = await safeSync(runner, {
     reason: "startup",
     refreshLimits: true,
@@ -3707,7 +3800,7 @@ async function watch2(runner) {
     deviceHeartbeatMs: DEVICE_HEARTBEAT_MS,
     cloudSyncIntervalMs: CLOUD_SYNC_INTERVAL_MS,
     maxCloudWritesPerDay: MAX_CLOUD_WRITES_PER_DAY
-  });
+  }, false);
   const paths = runner.watchPaths();
   const watcher = esm_default.watch(paths, {
     ignoreInitial: true,
@@ -3720,11 +3813,11 @@ async function watch2(runner) {
   let pending;
   let running = false;
   let scheduledAt = 0;
-  let blockedUntil = startupRetryAfter ? Date.now() + startupRetryAfter : 0;
+  let cloudBlockedUntil = startupRetryAfter ? Date.now() + startupRetryAfter : 0;
   const schedule = (request, delay = DEBOUNCE_MS) => {
     pending = mergeRequests(pending, request);
     if (running) return;
-    const target = Math.max(Date.now() + delay, blockedUntil);
+    const target = Date.now() + delay;
     if (timer && scheduledAt <= target) return;
     if (timer) clearTimeout(timer);
     scheduledAt = target;
@@ -3735,13 +3828,12 @@ async function watch2(runner) {
       pending = void 0;
       if (!next) return;
       running = true;
-      const retryAfterMs = await safeSync(runner, next);
+      const retryAfterMs = await safeSync(runner, next, Date.now() < cloudBlockedUntil);
       running = false;
       if (retryAfterMs) {
-        blockedUntil = Date.now() + retryAfterMs;
-        pending = mergeRequests(pending, next);
-      } else {
-        blockedUntil = 0;
+        cloudBlockedUntil = Date.now() + retryAfterMs;
+      } else if (Date.now() >= cloudBlockedUntil) {
+        cloudBlockedUntil = 0;
       }
       if (pending) {
         const queued = pending;
@@ -3776,43 +3868,53 @@ async function watch2(runner) {
   ${paths.join("\n  ")}
 Press Ctrl+C to stop.`);
   await new Promise((resolve4) => {
-    process.on("SIGINT", () => {
+    const stop = () => {
       clearInterval(refreshTimer);
       clearInterval(fallbackTimer);
       if (timer) clearTimeout(timer);
-      void watcher.close().then(resolve4);
-    });
+      void Promise.all([watcher.close(), localServer?.close()]).then(() => resolve4());
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
   });
 }
-async function safeSync(runner, request) {
+async function safeSync(runner, request, suppressCloudPublish) {
   try {
     const { reason, ...options } = request;
-    const { processedTurns, byProvider, published, cloudWritesToday } = await runner.syncOnce(options);
+    const { processedTurns, byProvider, published, cloudWritesToday, publicationError } = await runner.syncOnce({
+      ...options,
+      suppressCloudPublish
+    });
     if (processedTurns > 0) {
       const detail = Object.entries(byProvider).map(([p, n]) => `${p}:${n}`).join(" ");
       console.log(
-        `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] processed ${processedTurns} turn(s) locally (${detail}); ` + (published ? `cloud snapshot published (${cloudWritesToday}/16 today)` : "cloud snapshot queued")
+        `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] processed ${processedTurns} turn(s) locally (${detail}); ` + (published ? `cloud snapshot published (${cloudWritesToday}/${MAX_CLOUD_WRITES_PER_DAY} today)` : "cloud backup queued")
       );
     } else if (reason === "startup") {
       console.log(
-        `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] local snapshot ready; ` + (published ? `cloud snapshot published (${cloudWritesToday}/16 today)` : "cloud snapshot queued")
+        `[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}] local snapshot ready; ` + (published ? `cloud snapshot published (${cloudWritesToday}/${MAX_CLOUD_WRITES_PER_DAY} today)` : "cloud backup queued")
       );
     }
+    if (publicationError) return cloudRetryDelay(publicationError);
   } catch (err) {
-    if (err instanceof FirestoreRestError && err.status === 429) {
-      const retryAfter = Math.max(
-        err.retryAfterMs ?? 0,
-        QUOTA_RETRY_MS + Math.floor(Math.random() * QUOTA_RETRY_JITTER_MS)
-      );
-      console.error(
-        `Cloud sync paused: Firestore quota is exhausted; the local snapshot is safe. Retrying in ${Math.ceil(retryAfter / 6e4)}m.`
-      );
-      return retryAfter;
-    }
-    console.error(`Sync error: ${err.message}`);
+    console.error(`Local sync error: ${err.message}`);
     return 15e3;
   }
 }
+function cloudRetryDelay(error) {
+  if (error instanceof FirestoreRestError && error.status === 429) {
+    const retryAfter = Math.max(
+      error.retryAfterMs ?? 0,
+      QUOTA_RETRY_MS + Math.floor(Math.random() * QUOTA_RETRY_JITTER_MS)
+    );
+    console.error(
+      `Cloud backup paused: Firestore quota is exhausted; local live updates remain active. Retrying in ${Math.ceil(retryAfter / 6e4)}m.`
+    );
+    return retryAfter;
+  }
+  console.error(`Cloud backup error: ${error.message}. Local live updates remain active; retrying shortly.`);
+  return 6e4;
+}
 function mergeRequests(current, incoming) {
   if (!current) return incoming;
   return {
@@ -3902,7 +4004,8 @@ async function main(argv) {
       const lock = await acquireWatchLock();
       try {
         const runner = await createRunner();
-        const { processedTurns, processedLimits, byProvider } = await runner.syncOnce();
+        const { processedTurns, processedLimits, byProvider, publicationError } = await runner.syncOnce();
+        if (publicationError) throw publicationError;
         const detail = Object.entries(byProvider).map(([p, n]) => `${p}:${n}`).join(" ") || "none";
         console.log(`Processed ${processedTurns} turn(s) (${detail}); refreshed ${processedLimits} usage provider(s).`);
       } finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokelytics",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Tokelytics sync agent — streams local AI CLI usage logs (Claude Code, Codex) to your Tokelytics dashboard.",
   "license": "MIT",
   "type": "module",