usagemax 0.1.1 → 0.3.0

package/src/cli.js

@@ -1,25 +1,27 @@
 #!/usr/bin/env node
 
 import { execFile, spawn } from "node:child_process";
-import { createHash, randomUUID } from "node:crypto";
-import { chmod, mkdir, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { homedir, platform } from "node:os";
-import { delimiter, dirname, extname, join } from "node:path";
+import { dirname, join } from "node:path";
 import process from "node:process";
 import { promisify } from "node:util";
 
-import { batchId, buildDeltaPlan, normalizeLinkCode, sourceSummary, validHttpsUrl } from "./core.js";
+import { prepareArchiveRecovery } from "./archives.js";
+import { buildSessionPlan, buildSnapshotPlan, normalizeLinkCode, sourceSummary, validHttpsUrl } from "./core.js";
 import { stableInstallationId } from "./installation.js";
+import { CCUSAGE_VERSION, ccusageEnvironment, ccusageHome, discoverProviderArchives, SOURCE_INVENTORY_VERSION, sourceInventory, SUPPORTED_SOURCES } from "./sources.js";
 
 const require = createRequire(import.meta.url);
 const executeFile = promisify(execFile);
-const VERSION = "0.1.1";
-const DEFAULT_LINK_ENDPOINT = "https://terrific-bobcat-522.convex.site/v1/devices/link";
+const VERSION = "0.3.0";
+const PUBLIC_API_ORIGIN = "https://usagemax.com/api";
+const DEFAULT_LINK_ENDPOINT = `${PUBLIC_API_ORIGIN}/v1/devices/link`;
 const CONFIG_FILE = "config.json";
 const MAX_REPORT_BYTES = 100 * 1024 * 1024;
-const MAX_FINGERPRINT_FILES = 50_000;
-const USAGE_EXTENSIONS = new Set([".db", ".json", ".jsonl", ".sqlite", ".sqlite3"]);
+const FULL_RECONCILE_INTERVAL_MS = 7 * 24 * 60 * 60 * 1000;
 
 function configDirectory() {
   if (process.env.USAGEMAX_CONFIG_DIR) return process.env.USAGEMAX_CONFIG_DIR;
@@ -31,6 +33,18 @@ function configPath() {
   return join(configDirectory(), CONFIG_FILE);
 }
 
+function isLegacyDirectApi(config) {
+  try {
+    const ingest = new URL(config.ingestUrl);
+    const profile = new URL(config.profileUrl || "https://usagemax.com");
+    return profile.hostname === "usagemax.com"
+      && ingest.hostname.endsWith(".convex.site")
+      && ingest.pathname === "/v1/telemetry/llm";
+  } catch {
+    return false;
+  }
+}
+
 async function readConfig() {
   try {
     const parsed = JSON.parse(await readFile(configPath(), "utf8"));
@@ -38,6 +52,16 @@ async function readConfig() {
     if (!validHttpsUrl(parsed.ingestUrl, { allowLocalhost: true })) return null;
     if (typeof parsed.deviceId !== "string" || !parsed.deviceId) return null;
     parsed.snapshots = parsed.snapshots && typeof parsed.snapshots === "object" ? parsed.snapshots : {};
+    if (isLegacyDirectApi(parsed)) {
+      parsed.ingestUrl = `${PUBLIC_API_ORIGIN}/v1/telemetry/llm`;
+      parsed.snapshotUrl = `${PUBLIC_API_ORIGIN}/v2/usage/snapshots`;
+      parsed.revokeUrl = `${PUBLIC_API_ORIGIN}/v1/devices/revoke`;
+      await writeConfig(parsed);
+    }
+    parsed.snapshotUrl = validHttpsUrl(parsed.snapshotUrl, { allowLocalhost: true })
+      || parsed.ingestUrl.replace(/\/v1\/telemetry\/llm$/, "/v2/usage/snapshots");
+    parsed.revokeUrl = validHttpsUrl(parsed.revokeUrl, { allowLocalhost: true })
+      || parsed.ingestUrl.replace(/\/v1\/telemetry\/llm$/, "/v1/devices/revoke");
     return parsed;
   } catch {
     return null;
@@ -67,6 +91,7 @@ function option(args, name) {
 function deviceLabel() {
   if (platform() === "darwin") return "Mac";
   if (platform() === "win32") return "Windows PC";
+  if (platform() === "linux" && process.env.WSL_DISTRO_NAME) return `WSL · ${process.env.WSL_DISTRO_NAME}`;
   if (platform() === "linux") return "Linux computer";
   return "Computer";
 }
@@ -78,106 +103,76 @@ function help() {
   process.stdout.write("  usagemax                         Sync changed local usage\n");
   process.stdout.write("  usagemax link <one-use-code>     Link and sync this computer\n");
   process.stdout.write("           [--no-sync] [--name <name>]\n");
-  process.stdout.write("  usagemax sync [--full] [--json] Sync usage once, then exit\n");
+  process.stdout.write("  usagemax sync [--full] [--archives] [--dry-run] [--explain] [--json]\n");
+  process.stdout.write("                                  Reconcile once; --archives performs one-time recovery\n");
   process.stdout.write("  usagemax status                  Show local link status\n");
-  process.stdout.write("  usagemax doctor [--deep]         Check sources without parsing logs\n");
+  process.stdout.write("  usagemax doctor [--deep] [--json]\n");
+  process.stdout.write("                                  Check source coverage; --deep parses full history\n");
   process.stdout.write("  usagemax report [...args]        Run a local ccusage report\n");
-  process.stdout.write("  usagemax unlink                  Remove the local collector key\n");
+  process.stdout.write("  usagemax unlink [--revoke]       Remove locally; --revoke also disables uploads\n");
 }
 
 function ccusageCliPath() {
   return join(dirname(require.resolve("ccusage/package.json")), "src", "cli.js");
 }
 
-function configuredPaths(variable, fallbacks) {
-  const configured = process.env[variable];
-  return configured
-    ? configured.split(",").flatMap((group) => group.split(delimiter)).map((value) => value.trim()).filter(Boolean)
-    : fallbacks;
-}
-
-function usageRoots() {
-  const home = homedir();
-  return [
-    ["claude", configuredPaths("CLAUDE_CONFIG_DIR", [join(home, ".config", "claude", "projects"), join(home, ".claude", "projects")])],
-    ["codex", configuredPaths("CODEX_HOME", [join(home, ".codex", "sessions"), join(home, ".codex", "archived_sessions")])],
-    ["opencode", configuredPaths("OPENCODE_DATA_DIR", [join(home, ".local", "share", "opencode")])],
-    ["hermes", configuredPaths("HERMES_HOME", [join(home, ".hermes", "sessions")])],
-    ["pi", configuredPaths("PI_AGENT_DIR", [join(home, ".pi", "agent", "sessions")])],
-    ["copilot", configuredPaths("COPILOT_HOME", [join(home, ".copilot")])],
-    ["gemini", configuredPaths("GEMINI_DATA_DIR", [join(home, ".gemini", "tmp")])],
-  ].flatMap(([source, paths]) => paths.map((path) => ({ source, path })));
-}
-
-async function sourceInventory() {
-  const hash = createHash("sha256");
-  const sources = new Set();
-  const roots = usageRoots();
-  let files = 0;
-  let truncated = false;
-  for (const root of roots) {
-    try {
-      const rootStat = await stat(root.path);
-      if (!rootStat.isDirectory() && !rootStat.isFile()) continue;
-      sources.add(root.source);
-    } catch {
-      continue;
-    }
-    const stack = [root.path];
-    while (stack.length && files < MAX_FINGERPRINT_FILES) {
-      const current = stack.pop();
-      let entries;
-      try {
-        entries = await readdir(current, { withFileTypes: true });
-      } catch {
-        try {
-          const metadata = await stat(current);
-          if (metadata.isFile() && USAGE_EXTENSIONS.has(extname(current).toLowerCase())) {
-            hash.update(`${root.source}\u0000${current}\u0000${metadata.size}\u0000${metadata.mtimeMs}\n`);
-            files += 1;
-          }
-        } catch {}
-        continue;
-      }
-      for (const entry of entries) {
-        const path = join(current, entry.name);
-        if (entry.isDirectory()) {
-          if (!["node_modules", ".git", "cache", "tmp"].includes(entry.name)) stack.push(path);
-          continue;
-        }
-        if (!entry.isFile() || !USAGE_EXTENSIONS.has(extname(entry.name).toLowerCase())) continue;
-        try {
-          const metadata = await stat(path);
-          hash.update(`${root.source}\u0000${path}\u0000${metadata.size}\u0000${metadata.mtimeMs}\n`);
-          files += 1;
-        } catch {}
-        if (files >= MAX_FINGERPRINT_FILES) {
-          truncated = true;
-          break;
-        }
-      }
-    }
-  }
-  return { fingerprint: hash.digest("hex"), sources: [...sources].sort(), files, truncated };
-}
-
-async function ccusageJson(config, { full = false } = {}) {
-  const args = [ccusageCliPath(), "daily", "--json", "--offline", "--by-agent", "--order", "asc"];
+async function ccusageJson(config, { full = false, env } = {}) {
+  const args = [ccusageCliPath(), "daily", "--json", "--offline", "--mode", "calculate", "--timezone", "UTC", "--by-agent", "--order", "asc"];
+  args.push("--sections", "daily,session");
   // Reconcile yesterday once after the UTC date changes. All other incremental
   // scans parse only today; a metadata fingerprint avoids invoking ccusage when
   // no supported local source changed at all.
-  if (!full && config?.lastSyncAt) {
+  if (full) {
+    args.push("--since", "2024-01-01", "--until", new Date().toISOString().slice(0, 10));
+  } else if (config?.lastSyncAt) {
     const today = new Date().toISOString().slice(0, 10);
     args.push("--last", config.lastReconciledDay === today ? "1" : "2");
   }
   const { stdout } = await executeFile(process.execPath, args, {
     encoding: "utf8",
     maxBuffer: MAX_REPORT_BYTES,
-    env: { ...process.env, NO_COLOR: "1" },
+    env: { ...(env || await ccusageEnvironment()), NO_COLOR: "1" },
   });
   return JSON.parse(stdout);
 }
 
+function snapshotEndpoint(config) {
+  return validHttpsUrl(config.snapshotUrl, { allowLocalhost: true })
+    || config.ingestUrl.replace(/\/v1\/telemetry\/llm$/, "/v2/usage/snapshots");
+}
+
+async function snapshotRequest(config, operation, payload, timeout = 30_000) {
+  const response = await fetch(snapshotEndpoint(config), {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${config.token}`,
+      "content-type": "application/json",
+      "x-usagemax-device-id": config.deviceId,
+    },
+    body: JSON.stringify({ operation, ...payload }),
+    signal: AbortSignal.timeout(timeout),
+  });
+  const body = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    if (body?.error === "unauthorized") throw new Error("This collector key is no longer valid. Link the computer again.");
+    throw new Error(`UsageMax rejected ${operation} (${response.status}${body?.error ? `: ${body.error}` : ""}).`);
+  }
+  return body;
+}
+
+function newerVersion(recommended) {
+  if (!/^\d+\.\d+\.\d+$/.test(recommended || "")) return false;
+  const current = VERSION.split(".").map(Number);
+  const next = recommended.split(".").map(Number);
+  return next.some((value, index) => value > current[index] && next.slice(0, index).every((prior, priorIndex) => prior === current[priorIndex]));
+}
+
+function warnVersion(body) {
+  if (newerVersion(body?.recommendedCliVersion)) {
+    process.stderr.write(`UsageMax ${body.recommendedCliVersion} is available. Run \`bunx usagemax@latest\` for current coverage fixes.\n`);
+  }
+}
+
 async function link(args) {
   const code = normalizeLinkCode(args[0]);
   if (!code) throw new Error("Paste the one-use UMX link code shown at usagemax.com/account.");
@@ -198,13 +193,17 @@ async function link(args) {
   const body = await response.json().catch(() => ({}));
   if (!response.ok) throw new Error(body?.error === "invalid_or_expired_link_code" ? "That link code is invalid, expired, or already used." : "UsageMax could not link this computer.");
   const ingestUrl = validHttpsUrl(body.ingestUrl, { allowLocalhost: true });
-  if (!/^umx_[a-f0-9]{64}$/.test(body.token || "") || !ingestUrl) throw new Error("UsageMax returned an invalid link response.");
+  const snapshotUrl = validHttpsUrl(body.snapshotUrl, { allowLocalhost: true }) || ingestUrl?.replace(/\/v1\/telemetry\/llm$/, "/v2/usage/snapshots");
+  const revokeUrl = validHttpsUrl(body.revokeUrl, { allowLocalhost: true }) || ingestUrl?.replace(/\/v1\/telemetry\/llm$/, "/v1/devices/revoke");
+  if (!/^umx_[a-f0-9]{64}$/.test(body.token || "") || !ingestUrl || !snapshotUrl || !revokeUrl) throw new Error("UsageMax returned an invalid link response.");
   const profileHandle = typeof body.profileHandle === "string" ? body.profileHandle : undefined;
   const sameAccount = Boolean(previous && previous.profileHandle && previous.profileHandle === profileHandle);
   const config = {
     version: 1,
     token: body.token,
     ingestUrl,
+    snapshotUrl,
+    revokeUrl,
     profileUrl: validHttpsUrl(body.profileUrl) || "https://usagemax.com/account",
     profileHandle,
     deviceId,
@@ -213,6 +212,7 @@ async function link(args) {
     snapshots: sameAccount ? previous.snapshots : {},
   };
   await writeConfig(config);
+  warnVersion(body);
   process.stdout.write(`Linked ${name} to ${config.profileHandle ? `@${config.profileHandle}` : "UsageMax"}.\n`);
   if (args.includes("--no-sync")) {
     process.stdout.write("No usage was uploaded. Run `bunx usagemax sync --full` when you are ready.\n");
@@ -223,56 +223,139 @@ async function link(args) {
 }
 
 async function sync(args, suppliedConfig) {
+  const baseEnv = await ccusageEnvironment();
+  const recovery = args.includes("--archives")
+    ? await prepareArchiveRecovery(baseEnv)
+    : { archives: 0, cleanup: async () => undefined, env: baseEnv, unsupported: 0 };
+  try {
+    return await syncPrepared(args, suppliedConfig, recovery);
+  } finally {
+    await recovery.cleanup();
+  }
+}
+
+async function syncPrepared(args, suppliedConfig, recovery) {
   const config = suppliedConfig || await readConfig();
   if (!config) throw new Error("This computer is not linked. Open https://usagemax.com/account and create a link code.");
   config.deviceId = await stableInstallationId(configDirectory(), config.deviceId);
-  const full = args.includes("--full");
-  const inventory = await sourceInventory();
+  const requestedFull = args.includes("--full");
+  const requestedArchives = args.includes("--archives");
+  const dryRun = args.includes("--dry-run");
+  const explain = args.includes("--explain");
+  const json = args.includes("--json");
+  const inventory = await sourceInventory({ env: recovery.env, home: ccusageHome(recovery.env) });
   const today = new Date().toISOString().slice(0, 10);
-  if (!full && config.lastReconciledDay === today && config.sourceFingerprint === inventory.fingerprint) {
-    const result = { accepted: 0, changedRows: 0, sources: inventory.sources, regressions: 0, scanned: false };
-    if (args.includes("--json")) process.stdout.write(`${JSON.stringify(result)}\n`);
+  const knownSources = Array.isArray(config.knownSources) ? config.knownSources : [];
+  const foundNewSource = inventory.sources.some((source) => !knownSources.includes(source));
+  const lastFullSync = Date.parse(config.lastFullSyncAt || "");
+  const fullDue = config.snapshotProtocolVersion !== 2
+    || config.sourceInventoryVersion !== SOURCE_INVENTORY_VERSION
+    || !Number.isFinite(lastFullSync)
+    || Date.now() - lastFullSync >= FULL_RECONCILE_INTERVAL_MS
+    || foundNewSource;
+  const full = requestedFull || requestedArchives || fullDue;
+  if (!full && inventory.complete && config.lastSyncComplete && config.lastReconciledDay === today && config.sourceFingerprint === inventory.fingerprint) {
+    const result = { accepted: 0, changedRows: 0, sessions: 0, sources: inventory.sources, corrections: 0, scanned: false, full: false, coverage: inventory.complete ? "complete" : "partial" };
+    if (json) process.stdout.write(`${JSON.stringify(result)}\n`);
     else process.stdout.write("Already up to date. Local usage files have not changed; no logs were parsed or uploaded.\n");
     return;
   }
-  const report = await ccusageJson(config, { full });
-  const { plan, regressions } = buildDeltaPlan(report, config.snapshots, config.deviceId, "ccusage@20.0.20");
-  let accepted = 0;
-  for (let offset = 0; offset < plan.length; offset += 100) {
-    const batch = plan.slice(offset, offset + 100);
-    const events = batch.map((item) => item.event);
-    const response = await fetch(config.ingestUrl, {
-      method: "POST",
-      headers: {
-        authorization: `Bearer ${config.token}`,
-        "content-type": "application/json",
-        "idempotency-key": batchId(config.deviceId, events),
-        "x-usagemax-device-id": config.deviceId,
-      },
-      body: JSON.stringify({ events }),
-      signal: AbortSignal.timeout(30_000),
-    });
-    const body = await response.json().catch(() => ({}));
-    if (!response.ok) throw new Error(body?.error === "unauthorized" ? "This collector key is no longer valid. Link the computer again." : `UsageMax rejected a sync batch (${response.status}).`);
-    accepted += Number(body.accepted || 0);
-    for (const item of batch) config.snapshots[item.snapshotKey] = item.snapshot;
-    config.lastSyncAt = new Date().toISOString();
-    config.lastReconciledDay = today;
-    config.sourceFingerprint = inventory.fingerprint;
-    await writeConfig(config);
+  const report = await ccusageJson(config, { env: recovery.env, full });
+  const legacySnapshotBootstrap = config.snapshotProtocolVersion !== 2
+    && Object.keys(config.snapshots || {}).length > 0;
+  const runId = randomUUID();
+  const revision = Date.now();
+  const pricingVersion = `ccusage@${CCUSAGE_VERSION}`;
+  const { partitions, nextSnapshots, regressions } = buildSnapshotPlan(report, config.snapshots, {
+    bootstrap: config.snapshotProtocolVersion !== 2,
+    complete: inventory.complete,
+    full,
+    pricingVersion,
+    revision,
+    runId,
+  });
+  const sessions = buildSessionPlan(report, config.deviceId);
+  const sources = sourceSummary(report);
+  const days = Array.isArray(report?.daily)
+    ? report.daily.map((row) => row?.period).filter((day) => /^\d{4}-\d{2}-\d{2}$/.test(day || "")).sort()
+    : [];
+  const result = {
+    accepted: 0,
+    changedRows: partitions.reduce((sum, partition) => sum + partition.rows.filter((row) => JSON.stringify(row.previous) !== JSON.stringify(row.current)).length, 0),
+    sessions: sessions.length,
+    sources,
+    corrections: regressions.length,
+    partitions: partitions.length,
+    scanned: true,
+    full,
+    coverage: inventory.complete && !inventory.truncated && inventory.errors === 0 ? "complete" : "partial",
+    range: { from: days[0], to: days.at(-1) },
+  };
+  if (requestedArchives) {
+    result.archives = recovery.archives;
+    result.unsupportedArchives = recovery.unsupported;
+  }
+  if (dryRun) {
+    if (json) process.stdout.write(`${JSON.stringify({ ...result, dryRun: true })}\n`);
+    else {
+      process.stdout.write(`Dry run: ${partitions.length} partition(s), ${result.changedRows} changed row(s), ${sessions.length} private session identifiers, no upload.\n`);
+      if (explain) process.stdout.write(`Coverage ${result.coverage}; ${sources.length} source(s); ${days[0] || "unknown"} to ${days.at(-1) || "unknown"}; ${regressions.length} downward correction(s).\n`);
+    }
+    return result;
   }
-  if (!plan.length) {
+  config.lastSyncComplete = false;
+  await writeConfig(config);
+  try {
+    const begin = await snapshotRequest(config, "begin", {
+      runId,
+      mode: requestedArchives ? "archives" : full ? "full" : "incremental",
+      baselineMode: legacySnapshotBootstrap ? "adopt-current" : "apply",
+      sourceCount: sources.length,
+      partitionCount: partitions.length,
+      inventoryComplete: inventory.complete,
+      inventoryErrors: inventory.errors,
+      inventoryTruncated: inventory.truncated,
+      coverageStartDay: days[0],
+      coverageEndDay: days.at(-1),
+    });
+    warnVersion(begin);
+    for (let offset = 0; offset < sessions.length; offset += 100) {
+      await snapshotRequest(config, "sessions", { runId, sessions: sessions.slice(offset, offset + 100) });
+    }
+    for (let offset = 0; offset < partitions.length; offset += 10) {
+      const response = await snapshotRequest(config, "partitions", { runId, partitions: partitions.slice(offset, offset + 10) }, 60_000);
+      result.accepted += Number(response.changedRows || 0);
+      if (!json && process.stderr.isTTY && partitions.length > 10) {
+        process.stderr.write(`UsageMax: uploaded ${Math.min(offset + 10, partitions.length)}/${partitions.length} history partitions\r`);
+      }
+    }
+    if (!json && process.stderr.isTTY && partitions.length > 10) process.stderr.write("\n");
+    const completed = await snapshotRequest(config, "complete", { runId });
+    warnVersion(completed);
+    config.snapshots = nextSnapshots;
+    config.snapshotProtocolVersion = 2;
     config.lastSyncAt = new Date().toISOString();
     config.lastReconciledDay = today;
-    config.sourceFingerprint = inventory.fingerprint;
+    config.lastSyncComplete = true;
+    config.sourceInventoryVersion = SOURCE_INVENTORY_VERSION;
+    config.knownSources = [...new Set([...knownSources, ...inventory.sources, ...sources])].sort();
+    if (inventory.complete) config.sourceFingerprint = inventory.fingerprint;
+    else delete config.sourceFingerprint;
+    if (full) config.lastFullSyncAt = config.lastSyncAt;
     await writeConfig(config);
+  } catch (error) {
+    await snapshotRequest(config, "fail", { runId, failureCode: error instanceof Error ? error.message.slice(0, 80) : "sync_failed" }).catch(() => undefined);
+    throw error;
   }
-  const result = { accepted, changedRows: plan.length, sources: sourceSummary(report), regressions: regressions.length, scanned: true };
-  if (args.includes("--json")) process.stdout.write(`${JSON.stringify(result)}\n`);
+  if (json) process.stdout.write(`${JSON.stringify(result)}\n`);
   else {
-    process.stdout.write(plan.length ? `Synced ${accepted} changed usage rows from ${result.sources.join(", ") || "local agents"}.\n` : "Already up to date. No usage rows were uploaded.\n");
-    if (regressions.length) process.stdout.write(`${regressions.length} local row(s) moved backward; UsageMax kept the prior high-water mark to prevent double counting.\n`);
+    process.stdout.write(partitions.length || sessions.length
+      ? `Reconciled ${result.accepted} changed usage row(s) and ${sessions.length} session identifier(s) from ${sources.join(", ") || "local agents"}${full ? " across retained history" : ""}.\n`
+      : `Already up to date. No usage rows changed${full ? " after a full-history reconciliation" : ""}.\n`);
+    if (regressions.length) process.stdout.write(`${regressions.length} local row(s) moved backward and were submitted as authoritative corrections.\n`);
+    if (explain) process.stdout.write(`Coverage ${result.coverage}; ${sources.length} source(s); ${days[0] || "unknown"} to ${days.at(-1) || "unknown"}; ${partitions.length} atomic partition(s).\n`);
   }
+  return result;
 }
 
 async function status() {
@@ -288,24 +371,57 @@ async function status() {
   }
   process.stdout.write(`Linked: ${config.deviceName || deviceLabel()}${config.profileHandle ? ` → @${config.profileHandle}` : ""}\n`);
   process.stdout.write(`Last sync: ${config.lastSyncAt || "never"}\n`);
+  process.stdout.write(`Last full reconciliation: ${config.lastFullSyncAt || "never"}\n`);
   process.stdout.write(`Profile: ${config.profileUrl || "https://usagemax.com/account"}\n`);
 }
 
 async function doctor(args = []) {
   const config = await readConfig();
-  const inventory = await sourceInventory();
+  const env = await ccusageEnvironment();
+  const inventory = await sourceInventory({ env, home: ccusageHome(env) });
+  const archives = await discoverProviderArchives({ env, home: ccusageHome(env) });
+  const homes = String(env.USAGEMAX_DISCOVERED_HOMES || ccusageHome(env)).split(",").filter(Boolean);
+  const result = {
+    linked: Boolean(config),
+    homes,
+    detectedSources: inventory.sources,
+    files: inventory.files,
+    inventoryComplete: inventory.complete,
+    inventoryErrors: inventory.errors,
+    inventoryTruncated: inventory.truncated,
+    supportedSources: SUPPORTED_SOURCES,
+    archives: archives.length,
+    environment: platform() === "linux" && process.env.WSL_DISTRO_NAME ? `WSL ${process.env.WSL_DISTRO_NAME}` : platform(),
+    mode: args.includes("--deep") ? "deep" : "metadata-only",
+  };
+  if (args.includes("--deep")) {
+    const report = await ccusageJson(config, { env, full: true });
+    result.parsedSources = sourceSummary(report);
+    result.sessions = buildSessionPlan(report, config?.deviceId || "unlinked").length;
+  }
+  if (args.includes("--json")) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    return;
+  }
   process.stdout.write(`Collector: ${config ? "linked" : "not linked"}\n`);
+  process.stdout.write(`Discovered homes: ${homes.length} (${homes.join(", ")})\n`);
   process.stdout.write(`Detected sources: ${inventory.sources.join(", ") || "none"} (${inventory.files}${inventory.truncated ? "+" : ""} data files)\n`);
-  if (args.includes("--deep")) {
-    const report = await ccusageJson(config, { full: false });
-    process.stdout.write(`Parsed sources: ${sourceSummary(report).join(", ") || "none"}\n`);
+  process.stdout.write(`Supported sources: ${SUPPORTED_SOURCES.join(", ")} (+ named pi-format stores)\n`);
+  if (platform() === "linux" && process.env.WSL_DISTRO_NAME) {
+    process.stdout.write(`Environment: WSL ${process.env.WSL_DISTRO_NAME}; readable Windows provider homes are included automatically\n`);
   }
+  if (archives.length) process.stdout.write(`Recovery: ${archives.length} compressed provider archive(s) detected; run \`bunx usagemax sync --archives\` once to reconcile them\n`);
+  if (!inventory.complete) process.stdout.write(`Inventory: incomplete (${inventory.errors} read error(s)${inventory.truncated ? ", file limit reached" : ""}); no-change shortcut disabled\n`);
+  if (result.parsedSources) process.stdout.write(`Parsed sources: ${result.parsedSources.join(", ") || "none"}; ${result.sessions} private session identifiers\n`);
   process.stdout.write(`Mode: one-shot, metadata no-op check, ${args.includes("--deep") ? "deep local parse" : "no log parsing"}\n`);
 }
 
 async function report(args) {
   const forwarded = args.length ? args : ["daily"];
-  const child = spawn(process.execPath, [ccusageCliPath(), ...forwarded], { stdio: "inherit", env: process.env });
+  const child = spawn(process.execPath, [ccusageCliPath(), ...forwarded], {
+    stdio: "inherit",
+    env: await ccusageEnvironment(),
+  });
   const code = await new Promise((resolve, reject) => {
     child.once("error", reject);
     child.once("exit", (status) => resolve(status ?? 1));
@@ -313,15 +429,28 @@ async function report(args) {
   if (code !== 0) process.exitCode = code;
 }
 
-async function removeLink() {
+async function removeLink(args = []) {
   const path = configPath();
   const config = await readConfig();
   if (!config) {
     process.stdout.write("This computer is not linked.\n");
     return;
   }
+  if (args.includes("--revoke")) {
+    const endpoint = validHttpsUrl(config.revokeUrl, { allowLocalhost: true });
+    if (!endpoint) throw new Error("This collector does not have a valid revoke endpoint. Revoke it at https://usagemax.com/account.");
+    const response = await fetch(endpoint, {
+      method: "POST",
+      headers: { authorization: `Bearer ${config.token}`, "content-type": "application/json" },
+      body: JSON.stringify({ deviceId: config.deviceId }),
+      signal: AbortSignal.timeout(15_000),
+    });
+    if (!response.ok) throw new Error("UsageMax could not revoke this collector. It remains linked locally.");
+  }
   await unlink(path);
-  process.stdout.write("Removed the local UsageMax collector key. This computer's private installation identity was retained so relinking cannot duplicate its usage. Revoke the collector in your account if this computer is no longer trusted.\n");
+  process.stdout.write(args.includes("--revoke")
+    ? "Revoked this collector and removed its local key. Existing usage totals were retained.\n"
+    : "Removed the local UsageMax collector key. This computer's private installation identity was retained so relinking cannot duplicate its usage. Revoke the collector in your account if this computer is no longer trusted.\n");
 }
 
 async function main() {
@@ -334,7 +463,7 @@ async function main() {
   if (command === "status") return status();
   if (command === "doctor") return doctor(args.slice(1));
   if (command === "report") return report(args.slice(1));
-  if (command === "unlink") return removeLink();
+  if (command === "unlink") return removeLink(args.slice(1));
   throw new Error(`Unknown command: ${command}. Run usagemax --help.`);
 }