@totalreclaw/totalreclaw 1.3.0 → 1.5.0

package/README.md

@@ -79,9 +79,9 @@ Most of the time you won't use these directly -- the automatic hooks handle memo
 | Tier | Memories | Reads | Storage | Price |
 |------|----------|-------|---------|-------|
 | **Free** | 500/month | Unlimited | Testnet (trial) | $0 |
-| **Pro** | Unlimited | Unlimited | Permanent on-chain (Gnosis) | $5/month |
+| **Pro** | Unlimited | Unlimited | Permanent on-chain (Gnosis) | See `totalreclaw_status` |
 
-Pay with card via Stripe. Counter resets monthly.
+Pay with card via Stripe. Use `totalreclaw_status` to check current pricing. Counter resets monthly.
 
 ## Using with Other Agents
 

package/index.ts

@@ -9,6 +9,8 @@
  *   - totalreclaw_status       -- check billing/subscription status
  *   - totalreclaw_consolidate  -- scan and merge near-duplicate memories
  *   - totalreclaw_import_from  -- import memories from other tools (Mem0, MCP Memory, etc.)
+ *   - totalreclaw_upgrade      -- create Stripe checkout for Pro upgrade
+ *   - totalreclaw_migrate      -- migrate testnet memories to mainnet after Pro upgrade
  *
  * Also registers a `before_agent_start` hook that automatically injects
  * relevant memories into the agent's context.
@@ -134,6 +136,9 @@ const MAX_FACTS_PER_EXTRACTION = 15;
 // Store-time near-duplicate detection (consolidation module)
 const STORE_DEDUP_ENABLED = process.env.TOTALRECLAW_STORE_DEDUP !== 'false';
 
+// One-time welcome-back message for returning Pro users (set during init, consumed by first before_agent_start)
+let welcomeBackMessage: string | null = null;
+
 // B2: Minimum relevance threshold — cosine below this means no memory injection
 const RELEVANCE_THRESHOLD = parseFloat(process.env.TOTALRECLAW_RELEVANCE_THRESHOLD ?? '0.3');
 
@@ -421,6 +426,45 @@ async function initialize(logger: OpenClawPluginApi['logger']): Promise<void> {
       subgraphOwner = userId;
     }
   }
+
+  // One-time billing check for returning users (imported recovery phrase).
+  // If they already have an active Pro subscription, inform them on next conversation start.
+  if (existingUserId && authKeyHex) {
+    try {
+      const walletAddr = subgraphOwner || userId || '';
+      if (walletAddr) {
+        const billingUrl = (process.env.TOTALRECLAW_SERVER_URL || 'https://api.totalreclaw.xyz').replace(/\/+$/, '');
+        const resp = await fetch(`${billingUrl}/v1/billing/status?wallet_address=${encodeURIComponent(walletAddr)}`, {
+          method: 'GET',
+          headers: {
+            'Authorization': `Bearer ${authKeyHex}`,
+            'Accept': 'application/json',
+            'X-TotalReclaw-Client': 'openclaw-plugin',
+          },
+        });
+        if (resp.ok) {
+          const billingData = await resp.json() as Record<string, unknown>;
+          const tier = billingData.tier as string;
+          const expiresAt = billingData.expires_at as string | undefined;
+          // Populate billing cache for future use.
+          writeBillingCache({
+            tier: tier || 'free',
+            free_writes_used: (billingData.free_writes_used as number) ?? 0,
+            free_writes_limit: (billingData.free_writes_limit as number) ?? 0,
+            features: billingData.features as BillingCache['features'] | undefined,
+            checked_at: Date.now(),
+          });
+          if (tier === 'pro' && expiresAt) {
+            const expiryDate = new Date(expiresAt).toLocaleDateString();
+            welcomeBackMessage = `Welcome back! Your Pro subscription is active (expires: ${expiryDate}).`;
+            logger.info(`Returning Pro user detected — expires ${expiryDate}`);
+          }
+        }
+      }
+    } catch {
+      // Best-effort — don't block initialization on billing check failure.
+    }
+  }
 }
 
 function isDocker(): boolean {
@@ -682,6 +726,138 @@ function decryptFromHex(hexBlob: string, key: Buffer): string {
   return decrypt(b64, key);
 }
 
+// ---------------------------------------------------------------------------
+// Migration GraphQL helpers
+// ---------------------------------------------------------------------------
+
+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;
+}
+
+const MIGRATION_PAGE_SIZE = 1000;
+
+/** Execute a GraphQL query against a subgraph endpoint. Returns null on error. */
+async function migrationGqlQuery<T>(
+  endpoint: string,
+  query: string,
+  variables: Record<string, unknown>,
+  authKey?: string,
+): Promise<T | null> {
+  try {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'X-TotalReclaw-Client': 'openclaw-plugin',
+    };
+    if (authKey) headers['Authorization'] = `Bearer ${authKey}`;
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({ query, variables }),
+    });
+    if (!response.ok) return null;
+    const json = await response.json() as { data?: T; errors?: unknown[] };
+    return json.data ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** Fetch all active facts by owner from a subgraph, paginated. */
+async function fetchAllFactsByOwner(
+  subgraphUrl: string,
+  owner: string,
+  authKey: string,
+): Promise<MigrationFact[]> {
+  const allFacts: MigrationFact[] = [];
+  let lastId = '';
+
+  while (true) {
+    const hasLastId = lastId !== '';
+    const query = hasLastId
+      ? `query($owner:Bytes!,$first:Int!,$lastId:String!){facts(where:{owner:$owner,isActive:true,id_gt:$lastId},first:$first,orderBy:id,orderDirection:asc){id owner encryptedBlob encryptedEmbedding decayScore isActive contentFp source agentId version timestamp}}`
+      : `query($owner:Bytes!,$first:Int!){facts(where:{owner:$owner,isActive:true},first:$first,orderBy:id,orderDirection:asc){id owner encryptedBlob encryptedEmbedding decayScore isActive contentFp source agentId version timestamp}}`;
+    const vars: Record<string, unknown> = hasLastId
+      ? { owner, first: MIGRATION_PAGE_SIZE, lastId }
+      : { owner, first: MIGRATION_PAGE_SIZE };
+
+    const data = await migrationGqlQuery<{ facts?: MigrationFact[] }>(subgraphUrl, query, vars, authKey);
+    const facts = data?.facts ?? [];
+    if (facts.length === 0) break;
+    allFacts.push(...facts);
+    if (facts.length < MIGRATION_PAGE_SIZE) break;
+    lastId = facts[facts.length - 1].id;
+  }
+
+  return allFacts;
+}
+
+/** Fetch content fingerprints from a subgraph for idempotency. */
+async function fetchContentFingerprintsByOwner(
+  subgraphUrl: string,
+  owner: string,
+  authKey: string,
+): Promise<Set<string>> {
+  const fps = new Set<string>();
+  let lastId = '';
+
+  while (true) {
+    const hasLastId = lastId !== '';
+    const query = hasLastId
+      ? `query($owner:Bytes!,$first:Int!,$lastId:String!){facts(where:{owner:$owner,isActive:true,id_gt:$lastId},first:$first,orderBy:id,orderDirection:asc){id contentFp}}`
+      : `query($owner:Bytes!,$first:Int!){facts(where:{owner:$owner,isActive:true},first:$first,orderBy:id,orderDirection:asc){id contentFp}}`;
+    const vars: Record<string, unknown> = hasLastId
+      ? { owner, first: MIGRATION_PAGE_SIZE, lastId }
+      : { owner, first: MIGRATION_PAGE_SIZE };
+
+    const data = await migrationGqlQuery<{ facts?: Array<{ id: string; contentFp: string }> }>(subgraphUrl, query, vars, authKey);
+    const facts = data?.facts ?? [];
+    if (facts.length === 0) break;
+    for (const f of facts) {
+      if (f.contentFp) fps.add(f.contentFp);
+    }
+    if (facts.length < MIGRATION_PAGE_SIZE) break;
+    lastId = facts[facts.length - 1].id;
+  }
+
+  return fps;
+}
+
+/** Fetch blind index hashes for given fact IDs. */
+async function fetchBlindIndicesByFactIds(
+  subgraphUrl: string,
+  factIds: string[],
+  authKey: string,
+): Promise<Map<string, string[]>> {
+  const result = new Map<string, string[]>();
+  const CHUNK = 50;
+
+  for (let i = 0; i < factIds.length; i += CHUNK) {
+    const chunk = factIds.slice(i, i + CHUNK);
+    const query = `query($factIds:[String!]!,$first:Int!){blindIndexes(where:{fact_in:$factIds},first:$first){hash fact{id}}}`;
+    const data = await migrationGqlQuery<{
+      blindIndexes?: Array<{ hash: string; fact: { id: string } }>;
+    }>(subgraphUrl, query, { factIds: chunk, first: 1000 }, authKey);
+
+    for (const entry of data?.blindIndexes ?? []) {
+      const existing = result.get(entry.fact.id) || [];
+      existing.push(entry.hash);
+      result.set(entry.fact.id, existing);
+    }
+  }
+
+  return result;
+}
+
 /**
  * Fetch existing memories from the vault to provide dedup context for extraction.
  * Returns a lightweight list of {id, text} pairs for the LLM prompt.
@@ -2183,6 +2359,268 @@ const plugin = {
       { name: 'totalreclaw_import_from' },
     );
 
+    // ---------------------------------------------------------------
+    // Tool: totalreclaw_upgrade
+    // ---------------------------------------------------------------
+
+    api.registerTool(
+      {
+        name: 'totalreclaw_upgrade',
+        label: 'Upgrade to Pro',
+        description:
+          'Upgrade to TotalReclaw Pro for unlimited encrypted memories. ' +
+          'Returns a Stripe checkout URL for the user to complete payment via credit/debit card.',
+        parameters: {
+          type: 'object',
+          properties: {},
+          additionalProperties: false,
+        },
+        async execute() {
+          try {
+            await requireFullSetup(api.logger);
+
+            if (!authKeyHex) {
+              return {
+                content: [{ type: 'text', text: 'Auth credentials are not available. Please initialize first.' }],
+              };
+            }
+
+            const serverUrl = (process.env.TOTALRECLAW_SERVER_URL || 'https://api.totalreclaw.xyz').replace(/\/+$/, '');
+            const walletAddr = subgraphOwner || userId || '';
+
+            if (!walletAddr) {
+              return {
+                content: [{ type: 'text', text: 'Wallet address not available. Please ensure the plugin is fully initialized.' }],
+              };
+            }
+
+            const response = await fetch(`${serverUrl}/v1/billing/checkout`, {
+              method: 'POST',
+              headers: {
+                'Authorization': `Bearer ${authKeyHex}`,
+                'Content-Type': 'application/json',
+                'X-TotalReclaw-Client': 'openclaw-plugin',
+              },
+              body: JSON.stringify({
+                wallet_address: walletAddr,
+                tier: 'pro',
+              }),
+            });
+
+            if (!response.ok) {
+              const body = await response.text().catch(() => '');
+              return {
+                content: [{ type: 'text', text: `Failed to create checkout session (HTTP ${response.status}): ${body || response.statusText}` }],
+              };
+            }
+
+            const data = await response.json() as { checkout_url?: string };
+
+            if (!data.checkout_url) {
+              return {
+                content: [{ type: 'text', text: 'Failed to create checkout session: no checkout URL returned.' }],
+              };
+            }
+
+            return {
+              content: [{ type: 'text', text: `Open this URL to upgrade to Pro: ${data.checkout_url}` }],
+              details: { checkout_url: data.checkout_url },
+            };
+          } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            api.logger.error(`totalreclaw_upgrade failed: ${message}`);
+            return {
+              content: [{ type: 'text', text: `Failed to create checkout session: ${message}` }],
+            };
+          }
+        },
+      },
+      { name: 'totalreclaw_upgrade' },
+    );
+
+    // ---------------------------------------------------------------
+    // Tool: totalreclaw_migrate
+    // ---------------------------------------------------------------
+
+    api.registerTool(
+      {
+        name: 'totalreclaw_migrate',
+        label: 'Migrate Testnet to Mainnet',
+        description:
+          'Migrate memories from testnet (Base Sepolia) to mainnet (Gnosis) after upgrading to Pro. ' +
+          'Dry-run by default — set confirm=true to execute. Idempotent: re-running skips already-migrated facts.',
+        parameters: {
+          type: 'object',
+          properties: {
+            confirm: {
+              type: 'boolean',
+              description: 'Set to true to execute the migration. Without it, returns a dry-run preview.',
+              default: false,
+            },
+          },
+          additionalProperties: false,
+        },
+        async execute(_params: { confirm?: boolean }) {
+          try {
+            await requireFullSetup(api.logger);
+
+            if (!authKeyHex || !subgraphOwner) {
+              return {
+                content: [{ type: 'text', text: 'Plugin not fully initialized. Ensure TOTALRECLAW_RECOVERY_PHRASE is set.' }],
+              };
+            }
+
+            if (!isSubgraphMode()) {
+              return {
+                content: [{ type: 'text', text: 'Migration is only available with the managed service (subgraph mode).' }],
+              };
+            }
+
+            const confirm = _params?.confirm === true;
+            const serverUrl = (process.env.TOTALRECLAW_SERVER_URL || 'https://api.totalreclaw.xyz').replace(/\/+$/, '');
+
+            // 1. Check billing tier
+            const billingResp = await fetch(
+              `${serverUrl}/v1/billing/status?wallet_address=${encodeURIComponent(subgraphOwner)}`,
+              {
+                method: 'GET',
+                headers: {
+                  'Authorization': `Bearer ${authKeyHex}`,
+                  'Content-Type': 'application/json',
+                  'X-TotalReclaw-Client': 'openclaw-plugin',
+                },
+              },
+            );
+            if (!billingResp.ok) {
+              return { content: [{ type: 'text', text: `Failed to check billing tier (HTTP ${billingResp.status}).` }] };
+            }
+            const billingData = await billingResp.json() as { tier: string };
+            if (billingData.tier !== 'pro') {
+              return {
+                content: [{ type: 'text', text: 'Migration requires Pro tier. Use totalreclaw_upgrade to upgrade first.' }],
+              };
+            }
+
+            // 2. Fetch testnet facts via relay (chain=testnet query param)
+            const testnetSubgraphUrl = `${serverUrl}/v1/subgraph?chain=testnet`;
+            const mainnetSubgraphUrl = `${serverUrl}/v1/subgraph`;
+
+            api.logger.info('Fetching testnet facts...');
+            const testnetFacts = await fetchAllFactsByOwner(testnetSubgraphUrl, subgraphOwner, authKeyHex);
+
+            if (testnetFacts.length === 0) {
+              return {
+                content: [{ type: 'text', text: 'No facts found on testnet. Nothing to migrate.' }],
+              };
+            }
+
+            // 3. Check mainnet for existing facts (idempotency)
+            api.logger.info('Checking mainnet for existing facts...');
+            const mainnetFps = await fetchContentFingerprintsByOwner(mainnetSubgraphUrl, subgraphOwner, authKeyHex);
+            const factsToMigrate = testnetFacts.filter(f => !f.contentFp || !mainnetFps.has(f.contentFp));
+            const alreadyOnMainnet = testnetFacts.length - factsToMigrate.length;
+
+            // 4. Dry-run
+            if (!confirm) {
+              const msg = factsToMigrate.length === 0
+                ? `All ${testnetFacts.length} testnet facts already exist on mainnet. Nothing to migrate.`
+                : `Found ${factsToMigrate.length} facts to migrate from testnet to Gnosis mainnet (${alreadyOnMainnet} already on mainnet). Call with confirm=true to proceed.`;
+              return {
+                content: [{ type: 'text', text: msg }],
+                details: {
+                  mode: 'dry_run',
+                  testnet_facts: testnetFacts.length,
+                  already_on_mainnet: alreadyOnMainnet,
+                  to_migrate: factsToMigrate.length,
+                },
+              };
+            }
+
+            // 5. Execute migration
+            if (factsToMigrate.length === 0) {
+              return {
+                content: [{ type: 'text', text: `All ${testnetFacts.length} testnet facts already exist on mainnet. Nothing to migrate.` }],
+              };
+            }
+
+            // Fetch blind indices
+            api.logger.info(`Fetching blind indices for ${factsToMigrate.length} facts...`);
+            const factIds = factsToMigrate.map(f => f.id);
+            const blindIndicesMap = await fetchBlindIndicesByFactIds(testnetSubgraphUrl, factIds, authKeyHex);
+
+            // Build protobuf payloads
+            const payloads: Buffer[] = [];
+            for (const fact of factsToMigrate) {
+              const blobHex = fact.encryptedBlob.startsWith('0x') ? fact.encryptedBlob.slice(2) : fact.encryptedBlob;
+              const indices = blindIndicesMap.get(fact.id) || [];
+              const factPayload: FactPayload = {
+                id: fact.id,
+                timestamp: new Date().toISOString(),
+                owner: subgraphOwner,
+                encryptedBlob: blobHex,
+                blindIndices: indices,
+                decayScore: parseFloat(fact.decayScore) || 0.5,
+                source: fact.source || 'migration',
+                contentFp: fact.contentFp || '',
+                agentId: fact.agentId || 'openclaw-plugin',
+                encryptedEmbedding: fact.encryptedEmbedding || undefined,
+              };
+              payloads.push(encodeFactProtobuf(factPayload));
+            }
+
+            // Batch submit (15 per UserOp)
+            const BATCH_SIZE = 15;
+            const batchConfig = { ...getSubgraphConfig(), authKeyHex: authKeyHex!, walletAddress: subgraphOwner ?? undefined };
+            let migrated = 0;
+            let failedBatches = 0;
+
+            for (let i = 0; i < payloads.length; i += BATCH_SIZE) {
+              const batch = payloads.slice(i, i + BATCH_SIZE);
+              const batchNum = Math.floor(i / BATCH_SIZE) + 1;
+              const totalBatches = Math.ceil(payloads.length / BATCH_SIZE);
+              api.logger.info(`Migrating batch ${batchNum}/${totalBatches} (${batch.length} facts)...`);
+
+              try {
+                const result = await submitFactBatchOnChain(batch, batchConfig);
+                if (result.success) {
+                  migrated += batch.length;
+                } else {
+                  failedBatches++;
+                }
+              } catch (err: unknown) {
+                const msg = err instanceof Error ? err.message : String(err);
+                api.logger.error(`Migration batch ${batchNum} failed: ${msg}`);
+                failedBatches++;
+              }
+            }
+
+            const resultMsg = failedBatches === 0
+              ? `Successfully migrated ${migrated} memories from testnet to Gnosis mainnet.`
+              : `Migrated ${migrated}/${factsToMigrate.length} memories. ${failedBatches} batch(es) failed — re-run to retry (idempotent).`;
+
+            return {
+              content: [{ type: 'text', text: resultMsg }],
+              details: {
+                mode: 'executed',
+                testnet_facts: testnetFacts.length,
+                already_on_mainnet: alreadyOnMainnet,
+                to_migrate: factsToMigrate.length,
+                migrated,
+                failed_batches: failedBatches,
+              },
+            };
+          } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            api.logger.error(`totalreclaw_migrate failed: ${message}`);
+            return {
+              content: [{ type: 'text', text: `Migration failed: ${message}` }],
+            };
+          }
+        },
+      },
+      { name: 'totalreclaw_migrate' },
+    );
+
     // ---------------------------------------------------------------
     // Hook: before_agent_start
     // ---------------------------------------------------------------
@@ -2213,6 +2651,13 @@ const plugin = {
             };
           }
 
+          // One-time welcome-back message for returning Pro users.
+          let welcomeBack = '';
+          if (welcomeBackMessage) {
+            welcomeBack = `\n\n${welcomeBackMessage}`;
+            welcomeBackMessage = null; // Consume — only show once
+          }
+
           // Billing cache check — warn if quota is approaching limit.
           let billingWarning = '';
           try {
@@ -2286,7 +2731,7 @@ const plugin = {
                 const lines = cachedFacts.slice(0, 8).map((f, i) =>
                   `${i + 1}. ${f.text} (importance: ${f.importance}/10, cached)`,
                 );
-                return { prependContext: `## Relevant Memories\n\n${lines.join('\n')}` + billingWarning };
+                return { prependContext: `## Relevant Memories\n\n${lines.join('\n')}` + welcomeBack + billingWarning };
               }
             }
 
@@ -2299,7 +2744,7 @@ const plugin = {
               const lines = cachedFacts.slice(0, 8).map((f, i) =>
                 `${i + 1}. ${f.text} (importance: ${f.importance}/10, cached)`,
               );
-              return { prependContext: `## Relevant Memories\n\n${lines.join('\n')}` + billingWarning };
+              return { prependContext: `## Relevant Memories\n\n${lines.join('\n')}` + welcomeBack + billingWarning };
             }
 
             if (allTrapdoors.length === 0) return undefined;
@@ -2316,7 +2761,7 @@ const plugin = {
                 const lines = cachedFacts.slice(0, 8).map((f, i) =>
                   `${i + 1}. ${f.text} (importance: ${f.importance}/10, cached)`,
                 );
-                return { prependContext: `## Relevant Memories\n\n${lines.join('\n')}` + billingWarning };
+                return { prependContext: `## Relevant Memories\n\n${lines.join('\n')}` + welcomeBack + billingWarning };
               }
               return undefined;
             }
@@ -2328,7 +2773,7 @@ const plugin = {
               const lines = cachedFacts.slice(0, 8).map((f, i) =>
                 `${i + 1}. ${f.text} (importance: ${f.importance}/10, cached)`,
               );
-              return { prependContext: `## Relevant Memories\n\n${lines.join('\n')}` + billingWarning };
+              return { prependContext: `## Relevant Memories\n\n${lines.join('\n')}` + welcomeBack + billingWarning };
             }
 
             // 5. Decrypt subgraph results and build reranker input.
@@ -2434,7 +2879,7 @@ const plugin = {
             });
             const contextString = `## Relevant Memories\n\n${lines.join('\n')}`;
 
-            return { prependContext: contextString + billingWarning };
+            return { prependContext: contextString + welcomeBack + billingWarning };
           }
 
           // --- Server mode (existing behavior) ---
@@ -2546,7 +2991,7 @@ const plugin = {
           });
           const contextString = `## Relevant Memories\n\n${lines.join('\n')}`;
 
-          return { prependContext: contextString + billingWarning };
+          return { prependContext: contextString + welcomeBack + billingWarning };
         } catch (err: unknown) {
           // The hook must NEVER throw -- log and return undefined.
           const message = err instanceof Error ? err.message : String(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totalreclaw/totalreclaw",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "End-to-end encrypted memory for AI agents — portable, yours forever. Automatic extraction, semantic search, and on-chain storage",
   "type": "module",
   "keywords": [