@totalreclaw/totalreclaw 3.3.12 → 3.3.13

package/runtime/format-helpers.ts

@@ -0,0 +1,293 @@
+// ---------------------------------------------------------------------------
+// Pure formatting / resolution helpers
+// ---------------------------------------------------------------------------
+//
+// Extracted from index.ts. Every function here is a pure computation over its
+// arguments (plus imported constants / stateless helpers) — none reads the
+// plugin's mutable session state, so they carve cleanly out of the composing
+// entry point. No environment-variable reads live here (they stay in config.ts /
+// entry.ts per the OpenClaw env-harvesting scanner rule).
+
+import { encrypt, decrypt } from '../crypto/crypto.js';
+import { detectGatewayHost } from '../billing/gateway-url.js';
+import { isRunningInDocker } from '../fs-helpers.js';
+import { readBillingCache } from '../billing/billing-cache.js';
+import type { GatewayMode } from '../pairing/first-run.js';
+import type { OpenClawPluginApi } from './types.js';
+
+// ---------------------------------------------------------------------------
+// Human-friendly error messages
+// ---------------------------------------------------------------------------
+
+/**
+ * Translate technical error messages from the on-chain submission pipeline
+ * into user-friendly messages. The original technical details are still
+ * logged via api.logger — this only affects what the agent sees.
+ */
+export function humanizeError(rawMessage: string): string {
+  if (rawMessage.includes('AA23')) {
+    return 'Memory storage temporarily unavailable. Will retry next time.';
+  }
+  if (rawMessage.includes('AA10')) {
+    return 'Please wait a moment before storing more memories.';
+  }
+  if (rawMessage.includes('AA25')) {
+    return 'Memory storage busy. Will retry.';
+  }
+  if (rawMessage.includes('pm_sponsorUserOperation')) {
+    return 'Memory storage service temporarily unavailable.';
+  }
+  if (/Relay returned HTTP\s*404/.test(rawMessage)) {
+    return 'Memory service is temporarily offline.';
+  }
+  if (/Relay returned HTTP\s*5\d\d/.test(rawMessage)) {
+    return 'Memory service encountered a temporary error. Will retry next time.';
+  }
+  // Pass through non-technical messages as-is.
+  return rawMessage;
+}
+
+// ---------------------------------------------------------------------------
+// 3.3.0 — pairing URL resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Build the full pairing URL (including `#pk=` fragment) for a fresh
+ * pairing session. Pulls gateway config from `api.config.gateway`.
+ *
+ * Resolution order (3.3.1 — six-layer cascade):
+ *   1. `plugins.entries.totalreclaw.config.publicUrl` — explicit override
+ *   2. `gateway.remote.url` — OpenClaw's own remote-gateway URL
+ *   3. `gateway.bind === 'custom'` + `gateway.customBindHost` + port
+ *   4. Tailscale auto-detect — `tailscale status --json` → `https://<MagicDNS>`
+ *      (assumes `tailscale serve` proxies to the gateway port on 443)
+ *   5. LAN auto-detect — first non-loopback, non-virtual IPv4 interface.
+ *      Emits a warning: "only works on the same network".
+ *   6. Fallback `http://localhost:<port>` — warns with a pointer to
+ *      configure `plugins.entries.totalreclaw.config.publicUrl`.
+ *
+ * Always returns a working URL string; never throws. The caller (CLI or
+ * JSON output) prints whatever we give it.
+ */
+export function buildPairingUrl(
+  api: Pick<OpenClawPluginApi, 'config' | 'pluginConfig' | 'logger'>,
+  session: { sid: string; pkGatewayB64: string },
+): string {
+  const cfg = api.config as {
+    gateway?: {
+      port?: number;
+      bind?: string;
+      customBindHost?: string;
+      tls?: { enabled?: boolean };
+      remote?: { url?: string };
+    };
+  } | undefined;
+  const pluginCfg = (api.pluginConfig ?? {}) as { publicUrl?: string };
+
+  const tlsEnabled = cfg?.gateway?.tls?.enabled === true;
+  const scheme = tlsEnabled ? 'https' : 'http';
+  const port = cfg?.gateway?.port ?? 18789;
+
+  let base: string;
+
+  // Layer 1 — explicit user override
+  if (typeof pluginCfg.publicUrl === 'string' && pluginCfg.publicUrl.trim()) {
+    base = pluginCfg.publicUrl.replace(/\/+$/, '');
+    base = base.replace(/^wss:\/\//i, 'https://').replace(/^ws:\/\//i, 'http://');
+  }
+  // Layer 2 — OpenClaw gateway remote URL
+  else if (typeof cfg?.gateway?.remote?.url === 'string' && cfg.gateway.remote.url.trim()) {
+    base = cfg.gateway.remote.url.trim().replace(/\/+$/, '');
+    base = base.replace(/^wss:\/\//i, 'https://').replace(/^ws:\/\//i, 'http://');
+  }
+  // Layer 3 — gateway.bind = custom + explicit customBindHost
+  else if (cfg?.gateway?.bind === 'custom' && cfg.gateway.customBindHost) {
+    base = `${scheme}://${cfg.gateway.customBindHost}:${port}`;
+  }
+  // Layers 4 + 5 — auto-detect via gateway-url helper (Tailscale CGNAT, then LAN)
+  else {
+    let detected: ReturnType<typeof detectGatewayHost> = null;
+    // issue #110 fix 4 — pass `isDocker` so LAN detection skips
+    // 172.16/12 bridge IPs that no external browser can reach.
+    let isDocker = false;
+    try {
+      isDocker = isRunningInDocker();
+    } catch {
+      // Defensive: never block URL building on Docker sniff errors.
+      isDocker = false;
+    }
+    try {
+      detected = detectGatewayHost({ isDocker });
+    } catch (err) {
+      api.logger.warn(
+        `TotalReclaw: host autodetect crashed: ${err instanceof Error ? err.message : String(err)} — falling back to localhost`,
+      );
+    }
+    if (detected?.kind === 'tailscale') {
+      // 3.3.1-rc.2: we surface the raw Tailscale CGNAT IP because passive
+      // NIC detection (no subprocess) cannot resolve the MagicDNS name.
+      // Caller can override via `publicUrl` for a proper https://<magicdns>.
+      // The IP + port URL still works inside the tailnet (peers can reach
+      // each other by CGNAT IP directly). TLS defaults to the gateway's
+      // own config because we no longer assume `tailscale serve`.
+      base = `${scheme}://${detected.host}:${port}`;
+      api.logger.warn(
+        `TotalReclaw: pairing URL using Tailscale CGNAT IP ${detected.host}:${port} — ` +
+          detected.note,
+      );
+    } else if (detected?.kind === 'lan') {
+      base = `${scheme}://${detected.host}:${port}`;
+      api.logger.warn(
+        `TotalReclaw: pairing URL using LAN host ${detected.host}:${port} — ` +
+          `this URL only works from the same network. ` +
+          `Set plugins.entries.totalreclaw.config.publicUrl for remote access.`,
+      );
+    } else {
+      // Layer 6 — localhost fallback (or Docker-aware relay-pointer warning)
+      const bind = cfg?.gateway?.bind;
+      if (isDocker) {
+        // issue #110 fix 4: inside Docker the LAN IP is container-internal
+        // and useless. Loopback localhost only works for `docker exec`
+        // tests. The CORRECT pair URL for Docker is the relay-brokered
+        // path served by `tr pair` / the `/plugin/totalreclaw/pair/*` HTTP
+        // routes (CONFIG.pairMode === 'relay' since rc.11). The CLI-only
+        // path here cannot mint a relay session synchronously (the relay
+        // handshake needs a WS round-trip), so we emit the loopback URL
+        // with a LOUD warning pointing the operator at the pair CLI /
+        // publicUrl override.
+        api.logger.warn(
+          `TotalReclaw: Docker container detected — pairing URL falling back to ` +
+            `http://localhost:${port}, which is unreachable from the host browser. ` +
+            `Run \`tr pair --url-pin\` (or \`openclaw totalreclaw pair generate --url-pin-only\`) ` +
+            `on the gateway host to mint a relay-brokered pair URL that reaches the host browser, ` +
+            `OR set plugins.entries.totalreclaw.config.publicUrl ` +
+            `to your gateway's host-reachable URL (e.g. http://<host-ip>:${port} when the ` +
+            `Docker port is published). Setting TOTALRECLAW_PAIR_MODE=relay is the default; ` +
+            `air-gapped operators on TOTALRECLAW_PAIR_MODE=local must publish a port + set publicUrl.`,
+        );
+      } else if (bind === 'lan' || bind === 'tailnet') {
+        api.logger.warn(
+          `TotalReclaw: pairing URL falling back to localhost because gateway.bind=${bind} could not be autodetected. ` +
+            'Set plugins.entries.totalreclaw.config.publicUrl to override.',
+        );
+      } else {
+        api.logger.warn(
+          `TotalReclaw: pairing URL fell back to http://localhost:${port} — this URL only works on this machine. ` +
+            `Configure plugins.entries.totalreclaw.config.publicUrl for remote access.`,
+        );
+      }
+      base = `${scheme}://localhost:${port}`;
+    }
+  }
+
+  return `${base}/plugin/totalreclaw/pair/finish?sid=${encodeURIComponent(session.sid)}#pk=${encodeURIComponent(session.pkGatewayB64)}`;
+}
+
+/**
+ * Resolve whether this plugin is running on a `local` or `remote` gateway.
+ *
+ * Follows the same config surface `buildPairingUrl` uses:
+ *   - `pluginConfig.publicUrl` set + non-localhost     → remote
+ *   - `gateway.remote.url` set + non-localhost         → remote
+ *   - `gateway.bind === 'lan' | 'tailnet' | 'custom'`  → remote
+ *   - anything else                                    → local
+ *
+ * We treat a `publicUrl` or `remote.url` that points at `localhost` /
+ * `127.*` as local because that is what a dev-loopback override looks like;
+ * no one publishes a remote QR pairing for localhost.
+ */
+export function resolveGatewayMode(
+  api: Pick<OpenClawPluginApi, 'config' | 'pluginConfig'>,
+): GatewayMode {
+  const cfg = api.config as
+    | { gateway?: { bind?: string; remote?: { url?: string } } }
+    | undefined;
+  const pluginCfg = (api.pluginConfig ?? {}) as { publicUrl?: string };
+  const looksLocal = (url: string | undefined): boolean => {
+    if (!url) return true;
+    const u = url.trim().toLowerCase();
+    if (u === '') return true;
+    return /^(?:wss?:\/\/|https?:\/\/)?(?:localhost|127\.|0\.0\.0\.0)/.test(u);
+  };
+  if (typeof pluginCfg.publicUrl === 'string' && !looksLocal(pluginCfg.publicUrl)) {
+    return 'remote';
+  }
+  const remoteUrl = cfg?.gateway?.remote?.url;
+  if (typeof remoteUrl === 'string' && !looksLocal(remoteUrl)) {
+    return 'remote';
+  }
+  const bind = cfg?.gateway?.bind;
+  if (bind === 'lan' || bind === 'tailnet' || bind === 'custom') {
+    return 'remote';
+  }
+  return 'local';
+}
+
+// ---------------------------------------------------------------------------
+// Candidate-pool sizing
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute the candidate pool size from a fact count.
+ *
+ * Server-side config takes priority (from billing cache), then local fallback.
+ * The server computes the optimal pool based on vault size and tier caps.
+ *
+ * Local fallback formula: pool = min(max(factCount * 3, 400), 5000)
+ *   - At least 400 candidates (even for tiny vaults)
+ *   - At most 5000 candidates (to bound decryption + reranking cost)
+ *   - 3x fact count in between
+ */
+export function computeCandidatePool(factCount: number): number {
+  const cache = readBillingCache();
+  if (cache?.features?.max_candidate_pool != null) return cache.features.max_candidate_pool;
+  // Fallback to local formula if no server config
+  return Math.min(Math.max(factCount * 3, 400), 5000);
+}
+
+// ---------------------------------------------------------------------------
+// Encrypt/decrypt hex helpers (on-chain blob encoding)
+// ---------------------------------------------------------------------------
+
+export function encryptToHex(plaintext: string, key: Buffer): string {
+  const b64 = encrypt(plaintext, key);
+  return Buffer.from(b64, 'base64').toString('hex');
+}
+
+export function decryptFromHex(hexBlob: string, key: Buffer): string {
+  const hex = hexBlob.startsWith('0x') ? hexBlob.slice(2) : hexBlob;
+  const b64 = Buffer.from(hex, 'hex').toString('base64');
+  return decrypt(b64, key);
+}
+
+// ---------------------------------------------------------------------------
+// Lexical scoring / relative time
+// ---------------------------------------------------------------------------
+
+export function textScore(query: string, docText: string): number {
+  const queryWords = new Set(
+    query.toLowerCase().split(/\s+/).filter((w) => w.length >= 2),
+  );
+  const docWords = docText.toLowerCase().split(/\s+/);
+  let score = 0;
+  for (const word of docWords) {
+    if (queryWords.has(word)) score++;
+  }
+  return score;
+}
+
+/**
+ * Format a relative time string (e.g. "2 hours ago").
+ */
+export function relativeTime(isoOrMs: string | number): string {
+  const ms = typeof isoOrMs === 'number' ? isoOrMs : new Date(isoOrMs).getTime();
+  const diffMs = Date.now() - ms;
+  const seconds = Math.floor(diffMs / 1000);
+  if (seconds < 60) return 'just now';
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}

package/runtime/types.ts

@@ -0,0 +1,118 @@
+// ---------------------------------------------------------------------------
+// Shared plugin runtime types
+// ---------------------------------------------------------------------------
+//
+// Extracted from index.ts so the composing entry point AND the domain modules
+// carved out of it (runtime/format-helpers, import/import-runtime, …) can share
+// one definition of the OpenClaw plugin-API surface and the internal row shapes
+// without a circular import back through index.ts.
+//
+// Nothing here reads the environment or performs I/O — pure type declarations.
+
+/** OpenClaw Plugin API type (defined locally to avoid an SDK dependency). */
+export interface OpenClawPluginApi {
+  logger: {
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error(...args: unknown[]): void;
+  };
+  config?: {
+    agents?: {
+      defaults?: {
+        model?: {
+          primary?: string;
+        };
+      };
+    };
+    models?: {
+      providers?: Record<string, {
+        baseUrl: string;
+        apiKey?: string;
+        api?: string;
+        models?: Array<{ id: string; [k: string]: unknown }>;
+        [k: string]: unknown;
+      }>;
+      [k: string]: unknown;
+    };
+    [key: string]: unknown;
+  };
+  pluginConfig?: Record<string, unknown>;
+  registerTool(tool: unknown, opts?: { name?: string; names?: string[] }): void;
+  registerService(service: { id: string; start(): void; stop?(): void }): void;
+  on(hookName: string, handler: (...args: unknown[]) => unknown, opts?: { priority?: number }): void;
+  /**
+   * 3.2.0 — register a top-level `openclaw <cmd>` subcommand. The handler
+   * receives a commander `Command` to attach subcommands to. Output goes
+   * straight to the user's TTY; nothing touches the LLM or the transcript.
+   * We deliberately type `program` as `unknown` at this boundary because
+   * we don't import the SDK's full types; the runtime shape is commander's
+   * `Command` which we cast at the call site.
+   */
+  registerCli?(
+    registrar: (ctx: { program: unknown; config?: unknown; workspaceDir?: string; logger?: unknown }) => void | Promise<void>,
+    opts?: { commands?: string[] },
+  ): void;
+  /**
+   * 3.2.0 — register a slash command (e.g. `/totalreclaw`). The handler
+   * runs before the agent; its reply is delivered via the channel adapter.
+   * Reply text IS appended to the session transcript (see gateway-cli
+   * L9300-9312), so we only emit non-secret pointers.
+   */
+  registerCommand?(command: {
+    name: string;
+    description: string;
+    acceptsArgs?: boolean;
+    requireAuth?: boolean;
+    handler: (ctx: {
+      senderId?: string;
+      channel?: string;
+      args?: string;
+      commandBody?: string;
+      isAuthorizedSender?: boolean;
+      config?: unknown;
+    }) => { text: string } | Promise<{ text: string }>;
+  }): void;
+  /**
+   * 3.3.0 — register an HTTP route on the gateway's HTTP server.
+   * Used by the QR-pairing flow to serve the pairing page + the
+   * encrypted-payload respond endpoint. Path is exact-match against
+   * `new URL(req.url, ...).pathname`; no params supported.
+   */
+  registerHttpRoute?(params: {
+    path: string;
+    handler: (req: import('node:http').IncomingMessage, res: import('node:http').ServerResponse) => Promise<void> | void;
+    /** OpenClaw 2026.4.2+ — required; loader silently drops the route if absent. */
+    auth: 'gateway' | 'plugin';
+  }): void;
+}
+
+/** Row shape returned by the migration/export GraphQL helpers. */
+export interface MigrationFact {
+  id: string;
+  owner: string;
+  encryptedBlob: string;
+  encryptedEmbedding: string | null;
+  decayScore: string;
+  isActive: boolean;
+  contentFp: string;
+  source: string;
+  agentId: string;
+  version: number;
+  timestamp: string;
+}
+
+/** Smart import result containing profile, triage decisions, and enriched system prompt. */
+export interface SmartImportContext {
+  /** JSON-serialized UserProfile (for WASM calls that require profile_json) */
+  profileJson: string;
+  /** Triage decisions indexed by chunk_index */
+  decisions: Array<{ chunk_index: number; decision: string; reason: string }>;
+  /** Enriched system prompt for extraction (profile context injected) */
+  enrichedSystemPrompt: string;
+  /** Number of chunks marked for extraction */
+  extractCount: number;
+  /** Number of chunks marked for skipping */
+  skipCount: number;
+  /** Duration of the profiling + triage pipeline in ms */
+  durationMs: number;
+}

package/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "totalreclaw",
-  "version": "3.3.12-rc.23",
+  "version": "3.3.13",
   "description": "End-to-end encrypted memory for AI agents — portable, yours forever. XChaCha20-Poly1305 E2EE: server never sees plaintext.",
   "author": "TotalReclaw Team",
   "license": "MIT",
@@ -24,7 +24,10 @@
         "mode": {
           "type": "string",
           "required": false,
-          "enum": ["generate", "import"],
+          "enum": [
+            "generate",
+            "import"
+          ],
           "default": "generate",
           "description": "\"generate\" = browser will create a NEW recovery phrase. \"import\" = browser will accept an EXISTING phrase pasted by the user in their browser (never through chat)."
         }
@@ -43,7 +46,13 @@
         "type": {
           "type": "string",
           "required": false,
-          "enum": ["fact", "preference", "decision", "episodic", "goal"],
+          "enum": [
+            "fact",
+            "preference",
+            "decision",
+            "episodic",
+            "goal"
+          ],
           "default": "fact",
           "description": "Type of memory"
         },
@@ -95,7 +104,10 @@
         "format": {
           "type": "string",
           "required": false,
-          "enum": ["json", "markdown"],
+          "enum": [
+            "json",
+            "markdown"
+          ],
           "default": "json",
           "description": "Export format"
         }
@@ -121,7 +133,10 @@
         "source": {
           "type": "string",
           "required": true,
-          "enum": ["mem0", "mcp-memory"],
+          "enum": [
+            "mem0",
+            "mcp-memory"
+          ],
           "description": "Source system to import from"
         }
       }
@@ -149,7 +164,11 @@
       "bins": []
     },
     "emoji": "🧠",
-    "os": ["macos", "linux", "windows"],
+    "os": [
+      "macos",
+      "linux",
+      "windows"
+    ],
     "hooks": {
       "before_agent_start": {
         "priority": 10,
@@ -181,7 +200,13 @@
           "type": {
             "type": "string",
             "required": false,
-            "enum": ["fact", "preference", "decision", "episodic", "goal"],
+            "enum": [
+              "fact",
+              "preference",
+              "decision",
+              "episodic",
+              "goal"
+            ],
             "default": "fact",
             "description": "Type of memory"
           },
@@ -230,7 +255,10 @@
           "format": {
             "type": "string",
             "required": false,
-            "enum": ["json", "markdown"],
+            "enum": [
+              "json",
+              "markdown"
+            ],
             "default": "json",
             "description": "Export format"
           }
@@ -253,7 +281,10 @@
           "source": {
             "type": "string",
             "required": true,
-            "enum": ["mem0", "mcp-memory"],
+            "enum": [
+              "mem0",
+              "mcp-memory"
+            ],
             "description": "Source system to import from"
           },
           "api_key": {
@@ -309,7 +340,10 @@
           "mode": {
             "type": "string",
             "required": false,
-            "enum": ["generate", "import"],
+            "enum": [
+              "generate",
+              "import"
+            ],
             "default": "generate",
             "description": "\"generate\" = browser will create a NEW recovery phrase. \"import\" = browser will accept an EXISTING phrase pasted by the user in their browser (never through chat)."
           }

package/{confirm-indexed.ts → subgraph/confirm-indexed.ts}

@@ -28,7 +28,7 @@
 
 import { createRequire } from 'node:module';
 import { getSubgraphConfig } from './subgraph-store.js';
-import { buildRelayHeaders } from './relay-headers.js';
+import { buildRelayHeaders } from '../billing/relay-headers.js';
 
 /**
  * The four `wasmConfirmIndexed*` exports below ship in `@totalreclaw/core@2.3.x`

package/{subgraph-search.ts → subgraph/subgraph-search.ts}

@@ -21,9 +21,9 @@
  */
 
 import { getSubgraphConfig } from './subgraph-store.js';
-import { CONFIG } from './config.js';
-import { buildRelayHeaders } from './relay-headers.js';
-import { relayFetch } from './relay.js';
+import { CONFIG } from '../config.js';
+import { buildRelayHeaders } from '../billing/relay-headers.js';
+import { relayFetch } from '../billing/relay.js';
 
 export interface SubgraphSearchFact {
   id: string;
@@ -165,13 +165,13 @@ async function paginateChunk(
 ): Promise<void> {
   let lastId = '';
   while (allResults.size < maxCandidates) {
-    const data = await gqlQuery<SearchResponse>(
+    const subgraphResponse = await gqlQuery<SearchResponse>(
       subgraphUrl,
       PAGINATE_QUERY,
       { trapdoors: chunk, owner, first: PAGE_SIZE, lastId },
       authKeyHex,
     );
-    const entries = data?.blindIndexes ?? [];
+    const entries = subgraphResponse?.blindIndexes ?? [];
     if (entries.length === 0) break;
     collectFacts(entries, allResults);
     if (entries.length < PAGE_SIZE) break;
@@ -234,13 +234,13 @@ export async function searchSubgraph(
 
   const batchResults = await Promise.all(
     chunks.map(async (chunk) => {
-      const data = await gqlQuery<SearchResponse>(
+      const subgraphResponse = await gqlQuery<SearchResponse>(
         subgraphUrl,
         SEARCH_QUERY,
         { trapdoors: chunk, owner, first: PAGE_SIZE },
         authKeyHex,
       );
-      return { chunk, entries: data?.blindIndexes ?? [] };
+      return { chunk, entries: subgraphResponse?.blindIndexes ?? [] };
     }),
   );
 
@@ -298,14 +298,14 @@ export async function searchSubgraphBroadened(
     }
   `;
 
-  const data = await gqlQuery<{ facts?: SubgraphSearchFact[] }>(
+  const subgraphResponse = await gqlQuery<{ facts?: SubgraphSearchFact[] }>(
     subgraphUrl,
     query,
     { owner, first: Math.min(maxCandidates, 1000) },
     authKeyHex,
   );
 
-  return (data?.facts ?? []).filter(f => f.isActive !== false);
+  return (subgraphResponse?.facts ?? []).filter(f => f.isActive !== false);
 }
 
 /**
@@ -343,14 +343,14 @@ export async function fetchFactById(
     }
   `;
 
-  const data = await gqlQuery<{ fact?: (SubgraphSearchFact & { owner: string }) | null }>(
+  const subgraphResponse = await gqlQuery<{ fact?: (SubgraphSearchFact & { owner: string }) | null }>(
     subgraphUrl,
     query,
     { id: factId },
     authKeyHex,
   );
 
-  const fact = data?.fact;
+  const fact = subgraphResponse?.fact;
   if (!fact) return null;
   if (fact.isActive === false) return null;
   if (typeof fact.owner === 'string' && fact.owner.toLowerCase() !== owner.toLowerCase()) {
@@ -376,15 +376,15 @@ export async function getSubgraphFactCount(owner: string, authKeyHex?: string):
     }
   `;
 
-  const data = await gqlQuery<{ globalStates?: Array<{ totalFacts: string }> }>(
+  const subgraphResponse = await gqlQuery<{ globalStates?: Array<{ totalFacts: string }> }>(
     subgraphUrl,
     query,
     {},
     authKeyHex,
   );
 
-  if (data?.globalStates && data.globalStates.length > 0) {
-    const count = parseInt(data.globalStates[0].totalFacts, 10);
+  if (subgraphResponse?.globalStates && subgraphResponse.globalStates.length > 0) {
+    const count = parseInt(subgraphResponse.globalStates[0].totalFacts, 10);
     return isNaN(count) ? 0 : count;
   }