claudeusage-sync 0.2.0 → 0.3.0

package/dist/api/ingest-client.js

@@ -9,6 +9,11 @@ const ingestResponseSchema = z.object({
     updatedAt: z.string(),
     userId: z.string(),
 });
+const coverageResponseSchema = z.object({
+    accountWindowEnd: z.string().nullable(),
+    hasData: z.boolean(),
+    machineWindowEnd: z.string().nullable(),
+});
 export class NeedsReauth extends Error {
     constructor() {
         super("needs_reauth");
@@ -60,3 +65,24 @@ export async function postIngest(apiBase, token, payload) {
     }
     return ingestResponseSchema.parse(await response.json());
 }
+// Read-only probe of what the server already has for this account/machine, used to
+// reconcile a possibly-stale local watermark before declaring "nothing to sync".
+// Reuses the NeedsReauth / RateLimited contract so callers funnel a rejected token
+// into the same re-auth path as ingest.
+export async function getCoverage(apiBase, token, machineId) {
+    const response = await fetch(`${apiBase}/api/coverage?machineId=${encodeURIComponent(machineId)}`, {
+        headers: { authorization: `Bearer ${token}` },
+        method: "GET",
+    });
+    if (response.status === 401) {
+        throw new NeedsReauth();
+    }
+    if (response.status === 429) {
+        const retryAfterSec = Number(response.headers.get("retry-after") ?? "60");
+        throw new RateLimited(Number.isFinite(retryAfterSec) ? retryAfterSec : 60);
+    }
+    if (!response.ok) {
+        throw new Error(`coverage failed: ${response.status} ${await response.text().catch(() => "")}`);
+    }
+    return coverageResponseSchema.parse(await response.json());
+}

package/dist/cli.js

@@ -18,6 +18,7 @@ program
     .option("--token <token>", "use this sync token instead of the browser device flow (headless/CI)")
     .option("--dry-run", "parse and build the payload but do not upload")
     .option("--since <date>", "only read records newer than this YYYY-MM-DD")
+    .option("--full", "ignore the local watermark and re-upload your entire history (use after deleting + recreating your account)")
     .action((options) => {
     runSync(options).catch(handleError);
 });

package/dist/commands/sync.js

@@ -1,14 +1,15 @@
 import chalk from "chalk";
 import ora from "ora";
 import { buildPayload, latestWatermark } from "../aggregate/payload.js";
-import { IngestConflict, NeedsReauth, postIngest, RateLimited, } from "../api/ingest-client.js";
+import { getCoverage, IngestConflict, NeedsReauth, postIngest, RateLimited, } from "../api/ingest-client.js";
+import { computeMachineId } from "../auth/machine.js";
 import { deleteConfig, readConfig, writeConfig, } from "../auth/config.js";
 import { runDeviceFlow } from "../auth/device-flow.js";
 import { readPackageInfo } from "../package.js";
 import { dedupe, detectOutputTokenUndercount, recordWatermarkKey, } from "../parse/dedupe.js";
 import { streamAllRecords } from "../parse/jsonl.js";
 import { resolveClaudeDir } from "../parse/paths.js";
-const DEFAULT_API = "https://claudeusage.com";
+const DEFAULT_API = "https://www.claudeusage.com";
 const packageInfo = readPackageInfo(import.meta.url);
 function apiBase() {
     return (process.env.CLAUDEUSAGE_API ?? DEFAULT_API).replace(/\/$/, "");
@@ -77,7 +78,7 @@ function printDryRun(payload, records) {
     console.log("  cacheCreate: ", totals.cacheCreate);
     console.log("  cacheRead:   ", totals.cacheRead);
 }
-async function uploadWithReauth(base, token, payload) {
+async function uploadWithReauth(base, token, payload, allRecords, version) {
     const upload = ora(`uploading ${payload.dailyBuckets.length} day-buckets...`).start();
     try {
         const result = await postIngest(base, token, payload);
@@ -88,13 +89,32 @@ async function uploadWithReauth(base, token, payload) {
     }
     catch (error) {
         if (error instanceof NeedsReauth) {
-            upload.warn("token rejected; re-running device authorization");
+            upload.warn("token rejected; re-authorizing and re-uploading full history");
             await deleteConfig();
             const freshToken = await runDeviceFlow(base);
-            const result = await postIngest(base, freshToken, payload);
-            console.log(chalk.green(result.duplicate
-                ? "already synced after re-auth; duplicate upload ignored"
-                : `synced after re-auth (${result.newRecords} day-buckets, ${result.messageCount} messages)`));
+            // A rejected token means the account was reset/recreated, so it holds no
+            // prior data. Send the FULL history — not just the window after the old
+            // watermark, which would drop everything before the last sync. If the
+            // account actually still has data (e.g. only the token was revoked), the
+            // server rejects the overlap and we fall back to the incremental payload.
+            const fullPayload = buildPayload(dedupe(allRecords), version);
+            try {
+                const result = await postIngest(base, freshToken, fullPayload);
+                console.log(chalk.green(result.duplicate
+                    ? "already synced after re-auth; duplicate upload ignored"
+                    : `synced full history after re-auth (${result.newRecords} day-buckets, ${result.messageCount} messages)`));
+            }
+            catch (reError) {
+                if (reError instanceof IngestConflict && reError.code === "ingest_overlap") {
+                    const result = await postIngest(base, freshToken, payload);
+                    console.log(chalk.green(result.duplicate
+                        ? "already synced after re-auth; duplicate upload ignored"
+                        : `synced after re-auth (${result.newRecords} day-buckets, ${result.messageCount} messages)`));
+                }
+                else {
+                    throw reError;
+                }
+            }
             return freshToken;
         }
         if (error instanceof RateLimited) {
@@ -132,7 +152,11 @@ export async function runSync(options) {
         const cutoff = parseSince(options.since);
         filtered = allRecords.filter((record) => new Date(record.timestamp).getTime() >= cutoff);
     }
-    else if (config) {
+    else if (config && !options.full) {
+        // --full ignores the local watermark and re-sends the entire history. This
+        // is the recovery path after deleting + recreating an account: an ordinary
+        // incremental sync would only upload the window after the old watermark
+        // (often just the last day) to the brand-new, empty account.
         filtered = allRecords.filter((record) => afterWatermark(record, config));
     }
     const deduped = dedupe(filtered);
@@ -146,6 +170,16 @@ export async function runSync(options) {
         return;
     }
     if (payload.dailyBuckets.length === 0) {
+        // The local watermark filtered everything out — but it may be STALE (e.g. the
+        // account was deleted + recreated, so the server actually has nothing). Before
+        // declaring "nothing to do", reconcile against the server's real coverage so a
+        // plain `claudeusage-sync` self-heals and restores the full history with no
+        // flag. Skipped for headless --token runs (must never pop a browser) and the
+        // explicit --since / --full paths, which already choose the window themselves.
+        if (token && config && !options.full && !options.since && !options.token) {
+            await reconcileEmptyPayload(base, token, config, allRecords);
+            return;
+        }
         console.log(chalk.yellow("no new Claude Code usage records to sync."));
         if (config) {
             await writeConfig(config);
@@ -163,7 +197,7 @@ export async function runSync(options) {
         writableConfig.consentAcceptedAt = new Date().toISOString();
     }
     await writeConfig(writableConfig);
-    const finalToken = await uploadWithReauth(base, token, payload);
+    const finalToken = await uploadWithReauth(base, token, payload, allRecords, packageInfo.version);
     const watermark = latestWatermark(deduped);
     await writeConfig({
         ...writableConfig,
@@ -173,3 +207,91 @@ export async function runSync(options) {
     });
     console.log(chalk.bold("\nprofile:"), chalk.hex("#d97757")(`${base}/dashboard`));
 }
+// Reached when the local watermark says there is nothing new to upload. The
+// watermark can be STALE — most importantly after the account was deleted and
+// recreated, where the server now holds nothing but the old watermark still hides
+// the entire history. We probe the server's real coverage and, if it is behind,
+// re-upload exactly the missing window (the full history for a fresh account),
+// anchored on the per-machine ingest frontier so the overlap guard never trips.
+async function reconcileEmptyPayload(base, token, config, allRecords) {
+    const machineId = computeMachineId();
+    let activeToken = token;
+    const probe = ora("checking the server for your synced history...").start();
+    let coverage;
+    try {
+        coverage = await getCoverage(base, activeToken, machineId);
+        probe.stop();
+    }
+    catch (error) {
+        if (error instanceof NeedsReauth) {
+            // Token rejected: the account was deleted/recreated, or the token was
+            // revoked. Re-authorize, then RE-PROBE with the fresh token so we upload
+            // only what the (possibly brand-new) account is missing — never a blind
+            // full re-upload, which would double-count an account that still has data.
+            probe.warn("sync token no longer valid; re-authorizing");
+            await deleteConfig();
+            activeToken = await runDeviceFlow(base);
+            coverage = await getCoverage(base, activeToken, machineId);
+        }
+        else if (error instanceof RateLimited) {
+            probe.info("server busy; skipping the history check this run");
+            await persistNoop(base, config, activeToken, allRecords);
+            return;
+        }
+        else {
+            // 404 (older server without this endpoint) / 5xx / network — never break a
+            // routine no-op sync over a failed reconcile.
+            probe.warn("could not verify server coverage; skipping the history check");
+            await persistNoop(base, config, activeToken, allRecords);
+            return;
+        }
+    }
+    const frontier = coverage.machineWindowEnd;
+    let resyncRecords;
+    if (!coverage.hasData) {
+        // Empty account (the fresh-after-delete case) → send the entire history.
+        resyncRecords = frontier
+            ? allRecords.filter((record) => record.timestamp > frontier)
+            : allRecords;
+    }
+    else if (!frontier) {
+        // Account already holds data but this machine has no ingest frontier (e.g.
+        // the data came from another machine). Uploading could double-count, so no-op.
+        await persistNoop(base, config, activeToken, allRecords);
+        return;
+    }
+    else {
+        resyncRecords = allRecords.filter((record) => record.timestamp > frontier);
+    }
+    const resyncDeduped = dedupe(resyncRecords);
+    const resyncPayload = buildPayload(resyncDeduped, packageInfo.version);
+    if (resyncPayload.dailyBuckets.length === 0) {
+        // Server is already caught up with this machine — a genuine no-op.
+        await persistNoop(base, config, activeToken, allRecords);
+        return;
+    }
+    console.log(chalk.cyan(`server is missing history — restoring ${resyncPayload.dailyBuckets.length} day-buckets.`));
+    const writableConfig = { ...config, apiBase: base, token: activeToken };
+    if (!writableConfig.consentAcceptedAt) {
+        printUploadNotice(resyncPayload.dailyBuckets.length, resyncPayload.sessionCount);
+        writableConfig.consentAcceptedAt = new Date().toISOString();
+    }
+    await writeConfig(writableConfig);
+    const finalToken = await uploadWithReauth(base, activeToken, resyncPayload, allRecords, packageInfo.version);
+    const watermark = latestWatermark(resyncDeduped);
+    await writeConfig({
+        ...writableConfig,
+        ...watermark,
+        apiBase: base,
+        token: finalToken,
+    });
+    console.log(chalk.bold("\nprofile:"), chalk.hex("#d97757")(`${base}/dashboard`));
+}
+// Genuine "nothing to do": print the message and persist config with the latest
+// local record as the watermark (and any refreshed token), so the next run filters
+// from the right place even if we just re-authorized.
+async function persistNoop(base, config, token, allRecords) {
+    console.log(chalk.yellow("no new Claude Code usage records to sync."));
+    const watermark = latestWatermark(dedupe(allRecords));
+    await writeConfig({ ...config, ...watermark, apiBase: base, token });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudeusage-sync",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Sync your Claude Code usage stats to claudeusage.com",
   "keywords": [
     "claude",