@net-protocol/cli 0.1.42 → 0.1.44

package/dist/cli/index.mjs

@@ -6,16 +6,16 @@ import { createRequire } from 'module';
 import chalk4 from 'chalk';
 import * as fs6 from 'fs';
 import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
-import { OPTIMAL_CHUNK_SIZE, StorageClient, detectFileTypeFromBase64, base64ToDataUri, shouldSuggestXmlStorage, getStorageKeyBytes, encodeStorageKeyForUrl, chunkDataForStorage, CHUNKED_STORAGE_CONTRACT, STORAGE_CONTRACT as STORAGE_CONTRACT$1 } from '@net-protocol/storage';
-import { stringToHex, createWalletClient, http, hexToString, parseEther, encodeFunctionData, publicActions, concat, defineChain, decodeEventLog, createPublicClient, formatEther } from 'viem';
+import { OPTIMAL_CHUNK_SIZE, StorageClient, detectFileTypeFromBase64, base64ToDataUri, shouldSuggestXmlStorage, getStorageKeyBytes, chunkDataForStorage, CHUNKED_STORAGE_CONTRACT, STORAGE_CONTRACT as STORAGE_CONTRACT$1, encodeStorageKeyForUrl } from '@net-protocol/storage';
+import { createPublicClient, http, createWalletClient, stringToHex, hexToString, parseEther, encodeFunctionData, publicActions, concat, defineChain, decodeEventLog, formatEther, isAddress } from 'viem';
+import { getSupportedChains, getNetContract, getChainName, getChainRpcUrls, getPublicClient, getBaseDataSuffix, NetClient, toBytes32, getChainBlockExplorer, NULL_ADDRESS, getChainSlug } from '@net-protocol/core';
 import { privateKeyToAccount } from 'viem/accounts';
-import { getNetContract, getChainName, getPublicClient, getChainRpcUrls, getBaseDataSuffix, NetClient, toBytes32, NULL_ADDRESS } from '@net-protocol/core';
-import { createRelayX402Client, createRelaySession, checkBackendWalletBalance, fundBackendWallet, batchTransactions, submitTransactionsViaRelay, waitForConfirmations, retryFailedTransactions as retryFailedTransactions$1 } from '@net-protocol/relay';
+import { fundBackendWallet, checkBackendWalletBalance, createRelayX402Client, createRelaySession, batchTransactions, submitTransactionsViaRelay, waitForConfirmations, retryFailedTransactions as retryFailedTransactions$1 } from '@net-protocol/relay';
 import { isCommentTopic, parseCommentData, FeedRegistryClient, FeedClient, AgentRegistryClient, COMMENT_TOPIC_SUFFIX, FEED_TOPIC_PREFIX } from '@net-protocol/feeds';
 import '@net-protocol/chats';
 import { isNetrSupportedChain, NetrClient } from '@net-protocol/netr';
 import { PROFILE_PICTURE_STORAGE_KEY, PROFILE_METADATA_STORAGE_KEY, parseProfileMetadata, PROFILE_CANVAS_STORAGE_KEY, PROFILE_CSS_STORAGE_KEY, isValidUrl, getProfilePictureStorageArgs, STORAGE_CONTRACT, isValidXUsername, getProfileMetadataStorageArgs, isValidBio, isValidDisplayName, isValidTokenAddress, DEMO_THEMES, MAX_CSS_SIZE, isValidCSS, getProfileCSSStorageArgs, buildCSSPrompt } from '@net-protocol/profiles';
-import { base } from 'viem/chains';
+import { baseSepolia, base } from 'viem/chains';
 import * as path from 'path';
 import { join } from 'path';
 import { BazaarClient } from '@net-protocol/bazaar';
@@ -23,6 +23,7 @@ import * as os from 'os';
 import { homedir } from 'os';
 import * as readline from 'readline';
 import { discoverTokenPool, PURE_ALPHA_STRATEGY, UNIV234_POOLS_STRATEGY, encodePoolKey, DYNAMIC_SPLIT_STRATEGY, getTokenScoreKey, UPVOTE_PRICE_ETH, UPVOTE_APP, ScoreClient, ALL_STRATEGY_ADDRESSES, NULL_ADDRESS as NULL_ADDRESS$1, UserUpvoteClient, calculateUpvoteCost, USER_UPVOTE_CONTRACT } from '@net-protocol/score';
+import { RELAY_ACCESS_KEY, generateAgentChatTopic, AgentClient, isAgentChatTopic, parseAgentAddressFromTopic, buildSessionTypedData, NET_API_URL, exchangeSessionSignature, buildConversationAuthTypedData, NET_TESTNET_API_URL } from '@net-protocol/agents';
 
 var DEFAULT_CHAIN_ID = 8453;
 function getRequiredChainId(optionValue) {
@@ -129,6 +130,75 @@ function parseCommonOptionsWithDefault(options, supportsEncodeOnly = false) {
     rpcUrl: getRpcUrlWithBotchanFallback(options.rpcUrl)
   };
 }
+var WEBSITE_BASE = "https://netprotocol.app";
+var STORAGE_BASE = "https://storedon.net";
+function chainSlug(chainId) {
+  return getChainSlug({ chainId }) ?? null;
+}
+function stripFeedPrefix(topic) {
+  const lower = topic.toLowerCase();
+  return lower.startsWith("feed-") ? lower.slice(5) : lower;
+}
+function feedUrl(chainId, feedName) {
+  const slug = chainSlug(chainId);
+  if (!slug) return null;
+  return `${WEBSITE_BASE}/app/feed/${slug}/${stripFeedPrefix(feedName)}`;
+}
+function walletUrl(chainId, address) {
+  const slug = chainSlug(chainId);
+  if (!slug) return null;
+  return `${WEBSITE_BASE}/app/feed/${slug}/${address.toLowerCase()}`;
+}
+function profileUrl(chainId, address) {
+  const slug = chainSlug(chainId);
+  if (!slug) return null;
+  return `${WEBSITE_BASE}/app/profile/${slug}/${address.toLowerCase()}`;
+}
+function tokenUrl(chainId, tokenAddress) {
+  const slug = chainSlug(chainId);
+  if (!slug) return null;
+  return `${WEBSITE_BASE}/app/token/${slug}/${tokenAddress.toLowerCase()}`;
+}
+function storageUrl(chainId, operatorAddress, key) {
+  return `${STORAGE_BASE}/net/${chainId}/storage/load/${operatorAddress.toLowerCase()}/${encodeStorageKeyForUrl(
+    key
+  )}`;
+}
+function explorerTxUrl(chainId, txHash) {
+  const base9 = getChainBlockExplorer({ chainId })?.url;
+  if (!base9) return null;
+  return `${base9}/tx/${txHash}`;
+}
+function explorerAddressUrl(chainId, address) {
+  const base9 = getChainBlockExplorer({ chainId })?.url;
+  if (!base9) return null;
+  return `${base9}/address/${address}`;
+}
+function postIdToCommentParam(postId) {
+  const colon = postId.indexOf(":");
+  if (colon === -1) return postId;
+  return `${postId.slice(0, colon)}-${postId.slice(colon + 1)}`;
+}
+function postPermalink(chainId, opts) {
+  const slug = chainSlug(chainId);
+  if (!slug) return null;
+  const params = new URLSearchParams();
+  if (opts.globalIndex != null) {
+    params.set("index", String(opts.globalIndex));
+  } else if (opts.topic != null && opts.topicIndex != null) {
+    params.set("topic", stripFeedPrefix(opts.topic));
+    params.set("index", String(opts.topicIndex));
+  } else if (opts.user != null && opts.userIndex != null) {
+    params.set("user", opts.user.toLowerCase());
+    params.set("index", String(opts.userIndex));
+  } else {
+    return null;
+  }
+  if (opts.commentId) {
+    params.set("commentId", postIdToCommentParam(opts.commentId));
+  }
+  return `${WEBSITE_BASE}/app/feed/${slug}/post?${params.toString()}`;
+}
 async function checkNormalStorageExists(params) {
   const { storageClient, storageKey, operatorAddress, expectedContent } = params;
   const existing = await storageClient.get({
@@ -212,7 +282,7 @@ function extractTypedArgsFromTransaction(tx, type) {
 }
 function generateStorageUrl(operatorAddress, chainId, storageKey) {
   if (!operatorAddress) return void 0;
-  return `https://storedon.net/net/${chainId}/storage/load/${operatorAddress}/${encodeStorageKeyForUrl(storageKey)}`;
+  return storageUrl(chainId, operatorAddress, storageKey);
 }
 async function checkTransactionExists(params) {
   const { storageClient, tx, operatorAddress } = params;
@@ -1181,6 +1251,11 @@ async function executeStorageRead(options) {
         key: options.key,
         operator: options.operator,
         chainId: readOnlyOptions.chainId,
+        storageUrl: storageUrl(
+          readOnlyOptions.chainId,
+          options.operator,
+          options.key
+        ),
         text: result.text,
         data: options.raw ? result.data : result.data,
         isXml: result.isXml,
@@ -1373,7 +1448,7 @@ function registerStorageCommand(program2) {
     try {
       console.log(chalk4.blue(`\u{1F4C1} Reading file: ${options.file}`));
       const result = await uploadFile(uploadOptions);
-      const storageUrl = generateStorageUrl(
+      const storageUrl2 = generateStorageUrl(
         result.operatorAddress,
         commonOptions.chainId,
         options.key
@@ -1383,8 +1458,8 @@ function registerStorageCommand(program2) {
           chalk4.green(
             `\u2713 All data already stored - skipping upload
   Storage Key: ${options.key}
-  Skipped: ${result.transactionsSkipped} transaction(s)${storageUrl ? `
-  Storage URL: ${chalk4.cyan(storageUrl)}` : ""}`
+  Skipped: ${result.transactionsSkipped} transaction(s)${storageUrl2 ? `
+  Storage URL: ${chalk4.cyan(storageUrl2)}` : ""}`
           )
         );
         process.exit(0);
@@ -1397,8 +1472,8 @@ function registerStorageCommand(program2) {
   Storage Type: ${result.storageType === "xml" ? "XML" : "Normal"}
   Transactions Sent: ${result.transactionsSent}
   Transactions Skipped: ${result.transactionsSkipped}
-  Final Transaction Hash: ${result.finalHash || "N/A"}${storageUrl ? `
-  Storage URL: ${chalk4.cyan(storageUrl)}` : ""}`
+  Final Transaction Hash: ${result.finalHash || "N/A"}${storageUrl2 ? `
+  Storage URL: ${chalk4.cyan(storageUrl2)}` : ""}`
           )
         );
         process.exit(0);
@@ -1455,7 +1530,7 @@ function registerStorageCommand(program2) {
     try {
       console.log(chalk4.blue(`\u{1F4C1} Reading file: ${options.file}`));
       const result = await previewFile(previewOptions);
-      const storageUrl = generateStorageUrl(
+      const storageUrl2 = generateStorageUrl(
         result.operatorAddress,
         commonOptions.chainId,
         options.key
@@ -1491,8 +1566,8 @@ function registerStorageCommand(program2) {
       console.log(
         `  Operator Address: ${chalk4.gray(result.operatorAddress)}`
       );
-      if (storageUrl) {
-        console.log(`  Storage URL: ${chalk4.cyan(storageUrl)}`);
+      if (storageUrl2) {
+        console.log(`  Storage URL: ${chalk4.cyan(storageUrl2)}`);
       }
       if (result.needToStoreChunks === 0 && !result.metadataNeedsStorage) {
         console.log(
@@ -1566,9 +1641,9 @@ function registerStorageCommand(program2) {
       console.log(chalk4.blue(`\u{1F4C1} Reading file: ${options.file}`));
       console.log(chalk4.blue(`\u{1F517} Using relay API: ${options.apiUrl}`));
       const result = await uploadFileWithRelay(uploadRelayOptions);
-      const { privateKeyToAccount: privateKeyToAccount26 } = await import('viem/accounts');
-      const userAccount = privateKeyToAccount26(commonOptions.privateKey);
-      const storageUrl = generateStorageUrl(
+      const { privateKeyToAccount: privateKeyToAccount28 } = await import('viem/accounts');
+      const userAccount = privateKeyToAccount28(commonOptions.privateKey);
+      const storageUrl2 = generateStorageUrl(
         userAccount.address,
         commonOptions.chainId,
         options.key
@@ -1584,8 +1659,8 @@ function registerStorageCommand(program2) {
   Metadata Submitted: ${result.metadataSubmitted ? "Yes" : "No (already exists)"}
   Backend Wallet: ${result.backendWalletAddress}
   Chunk Transaction Hashes: ${result.chunkTransactionHashes.length > 0 ? result.chunkTransactionHashes.join(", ") : "None"}${result.metadataTransactionHash ? `
-  Metadata Transaction Hash: ${result.metadataTransactionHash}` : ""}${storageUrl ? `
-  Storage URL: ${chalk4.cyan(storageUrl)}` : ""}`
+  Metadata Transaction Hash: ${result.metadataTransactionHash}` : ""}${storageUrl2 ? `
+  Storage URL: ${chalk4.cyan(storageUrl2)}` : ""}`
           )
         );
         process.exit(0);
@@ -1934,33 +2009,25 @@ function registerMessageCommand(program2) {
   messageCommand.addCommand(readCommand);
   messageCommand.addCommand(countCommand);
 }
-var SUPPORTED_CHAINS = [
-  { id: 8453, name: "Base", type: "mainnet" },
-  { id: 1, name: "Ethereum", type: "mainnet" },
-  { id: 666666666, name: "Degen", type: "mainnet" },
-  { id: 5112, name: "Ham", type: "mainnet" },
-  { id: 57073, name: "Ink", type: "mainnet" },
-  { id: 130, name: "Unichain", type: "mainnet" },
-  { id: 999, name: "HyperEVM", type: "mainnet" },
-  { id: 9745, name: "Plasma", type: "mainnet" },
-  { id: 143, name: "Monad", type: "mainnet" },
-  { id: 84532, name: "Base Sepolia", type: "testnet" },
-  { id: 11155111, name: "Sepolia", type: "testnet" }
-];
 function registerChainsCommand(program2) {
   program2.command("chains").description("List supported chains").option("--json", "Output in JSON format").action((options) => {
+    const chains = getSupportedChains();
     if (options.json) {
-      console.log(JSON.stringify(SUPPORTED_CHAINS, null, 2));
+      console.log(JSON.stringify(chains, null, 2));
       return;
     }
     console.log(chalk4.white.bold("Supported Chains:\n"));
     console.log(chalk4.cyan("Mainnets:"));
-    SUPPORTED_CHAINS.filter((c) => c.type === "mainnet").forEach((chain) => {
-      console.log(`  ${chalk4.white(chain.name)} ${chalk4.gray(`(${chain.id})`)}`);
+    chains.filter((c) => c.type === "mainnet").forEach((chain) => {
+      console.log(
+        `  ${chalk4.white(chain.name)} ${chalk4.gray(`(${chain.chainId})`)}`
+      );
     });
     console.log(chalk4.cyan("\nTestnets:"));
-    SUPPORTED_CHAINS.filter((c) => c.type === "testnet").forEach((chain) => {
-      console.log(`  ${chalk4.white(chain.name)} ${chalk4.gray(`(${chain.id})`)}`);
+    chains.filter((c) => c.type === "testnet").forEach((chain) => {
+      console.log(
+        `  ${chalk4.white(chain.name)} ${chalk4.gray(`(${chain.chainId})`)}`
+      );
     });
   });
 }
@@ -2224,10 +2291,19 @@ async function executeTokenInfo(options) {
       const output = {
         address: tokenAddress,
         chainId: readOnlyOptions.chainId,
+        tokenUrl: tokenUrl(readOnlyOptions.chainId, tokenAddress),
+        explorerAddressUrl: explorerAddressUrl(
+          readOnlyOptions.chainId,
+          tokenAddress
+        ),
         token: {
           name: token.name,
           symbol: token.symbol,
           deployer: token.deployer,
+          deployerProfileUrl: profileUrl(
+            readOnlyOptions.chainId,
+            token.deployer
+          ),
           image: token.image,
           animation: token.animation || null,
           fid: token.fid.toString(),
@@ -2426,6 +2502,8 @@ async function executeProfileGet(options) {
       const output = {
         address: options.address,
         chainId: readOnlyOptions.chainId,
+        profileUrl: profileUrl(readOnlyOptions.chainId, options.address),
+        walletUrl: walletUrl(readOnlyOptions.chainId, options.address),
         profilePicture: profilePicture || null,
         displayName: displayName || null,
         xUsername: xUsername || null,
@@ -5678,38 +5756,70 @@ function formatComment(comment, depth) {
   ];
   return lines.join("\n");
 }
-function postToJson(post, index, commentCount) {
+function stripFeedPrefix2(topic) {
+  const match = topic.match(/^(.+?):comments:/);
+  const base9 = match ? match[1] : topic;
+  return base9.replace(/^feed-/i, "");
+}
+function postToJson(post, options) {
+  const { chainId, topicIndex, userIndex, globalIndex, commentCount } = options;
+  const feedName = stripFeedPrefix2(post.topic);
+  const postId = `${post.sender}:${post.timestamp}`;
+  const permalink = postPermalink(chainId, {
+    globalIndex,
+    topic: post.topic,
+    topicIndex,
+    user: userIndex !== void 0 ? post.sender : void 0,
+    userIndex
+  });
   const result = {
-    index,
+    postId,
+    permalink,
     sender: post.sender,
+    senderProfileUrl: profileUrl(chainId, post.sender),
+    senderWalletUrl: walletUrl(chainId, post.sender),
     text: post.text,
     timestamp: Number(post.timestamp),
+    feed: feedName,
+    feedUrl: feedUrl(chainId, feedName),
     topic: post.topic
   };
-  if (commentCount !== void 0) {
-    result.commentCount = commentCount;
-  }
-  if (post.data && post.data !== "0x") {
-    result.data = post.data;
-  }
+  if (topicIndex !== void 0) result.topicIndex = topicIndex;
+  if (userIndex !== void 0) result.userIndex = userIndex;
+  if (globalIndex !== void 0) result.globalIndex = globalIndex;
+  if (commentCount !== void 0) result.commentCount = commentCount;
+  if (post.data && post.data !== "0x") result.data = post.data;
   return result;
 }
-function feedToJson(feed, index) {
-  return {
+function feedToJson(feed, index, chainId) {
+  const result = {
     index,
     feedName: feed.feedName,
     registrant: feed.registrant,
     timestamp: feed.timestamp
   };
+  if (chainId !== void 0) {
+    result.feedUrl = feedUrl(chainId, feed.feedName);
+  }
+  return result;
 }
-function commentToJson(comment, depth) {
-  return {
+function commentToJson(comment, options) {
+  const { chainId, depth, parentPostUrl } = options;
+  const commentParam = `${comment.sender}-${comment.timestamp}`;
+  const permalink = parentPostUrl ? `${parentPostUrl}${parentPostUrl.includes("?") ? "&" : "?"}commentId=${commentParam}` : null;
+  const result = {
+    commentId: `${comment.sender}:${comment.timestamp}`,
+    permalink,
     sender: comment.sender,
+    senderProfileUrl: profileUrl(chainId, comment.sender),
     text: comment.text,
     timestamp: Number(comment.timestamp),
-    depth,
-    data: comment.data !== "0x" ? comment.data : void 0
+    depth
   };
+  if (comment.data !== "0x") {
+    result.data = comment.data;
+  }
+  return result;
 }
 function formatAgent(agent, index) {
   const timestamp = formatTimestamp(agent.timestamp);
@@ -5719,12 +5829,17 @@ function formatAgent(agent, index) {
   ];
   return lines.join("\n");
 }
-function agentToJson(agent, index) {
-  return {
+function agentToJson(agent, index, chainId) {
+  const result = {
     index,
     address: agent.address,
     timestamp: agent.timestamp
   };
+  if (chainId !== void 0) {
+    result.profileUrl = profileUrl(chainId, agent.address);
+    result.walletUrl = walletUrl(chainId, agent.address);
+  }
+  return result;
 }
 function printJson(data) {
   console.log(JSON.stringify(data, null, 2));
@@ -5742,7 +5857,11 @@ async function executeFeedList(options) {
       maxFeeds: options.limit ?? 50
     });
     if (options.json) {
-      printJson(feeds.map((feed, i) => feedToJson(feed, i)));
+      printJson(
+        feeds.map(
+          (feed, i) => feedToJson(feed, i, readOnlyOptions.chainId)
+        )
+      );
     } else {
       if (feeds.length === 0) {
         console.log(chalk4.yellow("No registered feeds found"));
@@ -5968,26 +6087,31 @@ async function executeFeedRead(feed, options) {
       return;
     }
     const fetchLimit = options.sender ? Math.max(limit * 5, 100) : limit;
-    let posts = await client.getFeedPosts({
+    const fetched = await client.getFeedPostsWithIndex({
       topic: normalizedFeed,
       maxPosts: fetchLimit
     });
+    let postsWithIndex = fetched.messages.map((post, i) => ({
+      post,
+      topicIndex: fetched.startIndex + i
+    }));
     if (options.sender) {
       const senderLower = options.sender.toLowerCase();
-      posts = posts.filter(
-        (post) => post.sender.toLowerCase() === senderLower
+      postsWithIndex = postsWithIndex.filter(
+        ({ post }) => post.sender.toLowerCase() === senderLower
       );
-      posts = posts.slice(0, limit);
+      postsWithIndex = postsWithIndex.slice(0, limit);
     }
     if (options.unseen) {
       const lastSeen = getLastSeenTimestamp(normalizedFeed);
       const myAddress = getMyAddress();
-      posts = posts.filter((post) => {
+      postsWithIndex = postsWithIndex.filter(({ post }) => {
         const isNew = lastSeen === null || Number(post.timestamp) > lastSeen;
         const isFromOther = !myAddress || post.sender.toLowerCase() !== myAddress;
         return isNew && isFromOther;
       });
     }
+    const posts = postsWithIndex.map(({ post }) => post);
     if (options.markSeen) {
       const allPosts = await client.getFeedPosts({
         topic: normalizedFeed,
@@ -6003,7 +6127,13 @@ async function executeFeedRead(feed, options) {
     );
     if (options.json) {
       printJson(
-        posts.map((post, i) => postToJson(post, i, commentCounts[i]))
+        postsWithIndex.map(
+          ({ post, topicIndex }, i) => postToJson(post, {
+            chainId: readOnlyOptions.chainId,
+            topicIndex,
+            commentCount: commentCounts[i]
+          })
+        )
       );
     } else {
       if (posts.length === 0) {
@@ -6065,6 +6195,34 @@ async function executeTransaction(walletClient, txConfig) {
   });
   return hash;
 }
+async function getMessageIndicesFromTx(params) {
+  const publicClient = getPublicClient({
+    chainId: params.chainId,
+    rpcUrl: params.rpcUrl
+  });
+  const netContract = getNetContract(params.chainId);
+  const contractAddress = netContract.address.toLowerCase();
+  const receipt = await publicClient.waitForTransactionReceipt({
+    hash: params.txHash
+  });
+  const indices = [];
+  for (const log of receipt.logs) {
+    if (log.address.toLowerCase() !== contractAddress) continue;
+    try {
+      const decoded = decodeEventLog({
+        abi: netContract.abi,
+        data: log.data,
+        topics: log.topics
+      });
+      if (decoded.eventName === "MessageSent") {
+        const args = decoded.args;
+        indices.push(Number(args.messageIndex));
+      }
+    } catch {
+    }
+  }
+  return indices;
+}
 
 // src/commands/feed/post.ts
 var MAX_MESSAGE_LENGTH = 4e3;
@@ -6116,11 +6274,23 @@ ${options.body}` : message;
     commonOptions.chainId,
     commonOptions.rpcUrl
   );
-  console.log(chalk4.blue(`Posting to feed "${normalizedFeed}"...`));
+  if (!options.json) {
+    console.log(chalk4.blue(`Posting to feed "${normalizedFeed}"...`));
+  }
   try {
     const hash = await executeTransaction(walletClient, txConfig);
     const senderAddress = walletClient.account.address;
     let postId;
+    let globalIndex;
+    try {
+      const indices = await getMessageIndicesFromTx({
+        chainId: commonOptions.chainId,
+        rpcUrl: commonOptions.rpcUrl,
+        txHash: hash
+      });
+      globalIndex = indices[0];
+    } catch {
+    }
     try {
       const posts = await client.getFeedPosts({
         topic: normalizedFeed,
@@ -6142,19 +6312,36 @@ ${options.body}` : message;
       sender: senderAddress,
       text: fullMessage,
       postId
-      // Now we have the actual post ID for checking comments later
     });
+    const permalink = postPermalink(commonOptions.chainId, {
+      globalIndex
+    });
+    if (options.json) {
+      printJson({
+        success: true,
+        txHash: hash,
+        explorerTxUrl: explorerTxUrl(commonOptions.chainId, hash),
+        postId,
+        globalIndex,
+        permalink,
+        feed: normalizedFeed,
+        feedUrl: feedUrl(commonOptions.chainId, normalizedFeed),
+        sender: senderAddress,
+        senderProfileUrl: profileUrl(commonOptions.chainId, senderAddress),
+        text: fullMessage
+      });
+      return;
+    }
     const displayText = options.body ? `${message} (+ body)` : message;
-    const postIdInfo = postId ? `
-  Post ID: ${postId}` : "";
-    console.log(
-      chalk4.green(
-        `Message posted successfully!
-  Transaction: ${hash}
-  Feed: ${normalizedFeed}${postIdInfo}
-  Text: ${displayText}`
-      )
-    );
+    const lines = [
+      `Message posted successfully!`,
+      `  Transaction: ${hash}`,
+      `  Feed: ${normalizedFeed}`
+    ];
+    if (postId) lines.push(`  Post ID: ${postId}`);
+    if (permalink) lines.push(`  Permalink: ${permalink}`);
+    lines.push(`  Text: ${displayText}`);
+    console.log(chalk4.green(lines.join("\n")));
   } catch (error) {
     exitWithError(
       `Failed to post message: ${error instanceof Error ? error.message : String(error)}`
@@ -6169,7 +6356,10 @@ function registerFeedPostCommand(parent) {
   ).option("--rpc-url <url>", "Custom RPC URL").option("--private-key <key>", "Private key (0x-prefixed)").option(
     "--encode-only",
     "Output transaction data as JSON instead of executing"
-  ).option("--data <data>", "Optional data to attach to the post").option("--body <text>", "Post body (message becomes the title)").action(async (feed, message, options) => {
+  ).option("--data <data>", "Optional data to attach to the post").option("--body <text>", "Post body (message becomes the title)").option(
+    "--json",
+    "Output structured JSON (includes permalink and other URLs) after submission"
+  ).action(async (feed, message, options) => {
     await executeFeedPost(feed, message, options);
   });
 }
@@ -6198,11 +6388,6 @@ function parsePostId(postId) {
     timestamp
   };
 }
-function findPostByParsedId(posts, parsedId) {
-  return posts.find(
-    (p) => p.sender.toLowerCase() === parsedId.sender.toLowerCase() && p.timestamp === parsedId.timestamp
-  );
-}
 
 // src/commands/feed/comment-write.ts
 var MAX_MESSAGE_LENGTH2 = 4e3;
@@ -6235,17 +6420,20 @@ async function executeFeedCommentWrite(feed, postId, message, options) {
       `Feed "${normalizedFeed}" has no posts. Cannot find post ${postId}.`
     );
   }
-  const posts = await client.getFeedPosts({
+  const fetched = await client.getFeedPostsWithIndex({
     topic: normalizedFeed,
     maxPosts: 100
-    // Fetch enough to find the post
   });
-  const targetPost = findPostByParsedId(posts, parsedId);
+  const matchOffset = fetched.messages.findIndex(
+    (p) => p.sender.toLowerCase() === parsedId.sender.toLowerCase() && p.timestamp === parsedId.timestamp
+  );
+  const targetPost = matchOffset >= 0 ? fetched.messages[matchOffset] : void 0;
   if (!targetPost) {
     exitWithError(
       `Post not found with ID ${postId} in feed "${normalizedFeed}". Make sure the sender and timestamp are correct.`
     );
   }
+  const parentTopicIndex = fetched.startIndex + matchOffset;
   const txConfig = client.prepareComment({
     post: targetPost,
     text: message
@@ -6269,26 +6457,81 @@ async function executeFeedCommentWrite(feed, postId, message, options) {
     commonOptions.chainId,
     commonOptions.rpcUrl
   );
-  console.log(chalk4.blue(`Commenting on post ${postId}...`));
+  if (!options.json) {
+    console.log(chalk4.blue(`Commenting on post ${postId}...`));
+  }
   try {
     const hash = await executeTransaction(walletClient, txConfig);
+    const senderAddress = walletClient.account.address;
+    let globalIndex;
+    try {
+      const indices = await getMessageIndicesFromTx({
+        chainId: commonOptions.chainId,
+        rpcUrl: commonOptions.rpcUrl,
+        txHash: hash
+      });
+      globalIndex = indices[0];
+    } catch {
+    }
+    let commentTimestamp;
+    if (globalIndex !== void 0) {
+      try {
+        const netClient = createNetClient(commonOptions);
+        const fetchedComment = await netClient.getMessageAtIndex({
+          messageIndex: globalIndex
+        });
+        if (fetchedComment) {
+          commentTimestamp = Number(fetchedComment.timestamp);
+        }
+      } catch {
+      }
+    }
     addHistoryEntry({
       type: "comment",
       txHash: hash,
       chainId: commonOptions.chainId,
       feed: normalizedFeed,
-      sender: walletClient.account.address,
+      sender: senderAddress,
       text: message,
       postId
     });
-    console.log(
-      chalk4.green(
-        `Comment posted successfully!
-  Transaction: ${hash}
-  Post: ${postId}
-  Comment: ${message}`
-      )
-    );
+    const parentPostUrl = postPermalink(commonOptions.chainId, {
+      topic: normalizedFeed,
+      topicIndex: parentTopicIndex
+    });
+    const commentPermalink = commentTimestamp !== void 0 ? postPermalink(commonOptions.chainId, {
+      topic: normalizedFeed,
+      topicIndex: parentTopicIndex,
+      commentId: `${senderAddress}-${commentTimestamp}`
+    }) : postPermalink(commonOptions.chainId, { globalIndex });
+    if (options.json) {
+      printJson({
+        success: true,
+        txHash: hash,
+        explorerTxUrl: explorerTxUrl(commonOptions.chainId, hash),
+        globalIndex,
+        permalink: commentPermalink,
+        parentPostId: postId,
+        parentPostUrl,
+        feed: normalizedFeed,
+        feedUrl: feedUrl(commonOptions.chainId, normalizedFeed),
+        sender: senderAddress,
+        senderProfileUrl: profileUrl(commonOptions.chainId, senderAddress),
+        text: message,
+        ...commentTimestamp !== void 0 && {
+          commentId: `${senderAddress}:${commentTimestamp}`
+        }
+      });
+      return;
+    }
+    const lines = [
+      `Comment posted successfully!`,
+      `  Transaction: ${hash}`,
+      `  Post: ${postId}`
+    ];
+    if (commentPermalink) lines.push(`  Permalink: ${commentPermalink}`);
+    lines.push(`  Comment: ${message}`);
+    console.log(chalk4.green(lines.join("\n")));
   } catch (error) {
     exitWithError(
       `Failed to post comment: ${error instanceof Error ? error.message : String(error)}`
@@ -6305,6 +6548,9 @@ function registerFeedCommentWriteCommand(parent) {
   ).option("--rpc-url <url>", "Custom RPC URL").option("--private-key <key>", "Private key (0x-prefixed)").option(
     "--encode-only",
     "Output transaction data as JSON instead of executing"
+  ).option(
+    "--json",
+    "Output structured JSON (includes permalink and other URLs) after submission"
   ).action(async (feed, postId, message, options) => {
     await executeFeedCommentWrite(feed, postId, message, options);
   });
@@ -6331,17 +6577,25 @@ async function executeFeedCommentRead(feed, postId, options) {
         `Feed "${normalizedFeed}" has no posts. Cannot find post ${postId}.`
       );
     }
-    const posts = await client.getFeedPosts({
+    const fetched = await client.getFeedPostsWithIndex({
       topic: normalizedFeed,
       maxPosts: 100
       // Fetch enough to find the post
     });
-    const targetPost = findPostByParsedId(posts, parsedId);
+    const matchIndex = fetched.messages.findIndex(
+      (p) => p.sender.toLowerCase() === parsedId.sender.toLowerCase() && p.timestamp === parsedId.timestamp
+    );
+    const targetPost = matchIndex >= 0 ? fetched.messages[matchIndex] : void 0;
     if (!targetPost) {
       exitWithError(
         `Post not found with ID ${postId} in feed "${normalizedFeed}". Make sure the sender and timestamp are correct.`
       );
     }
+    const parentTopicIndex = fetched.startIndex + matchIndex;
+    const parentPostUrl = postPermalink(readOnlyOptions.chainId, {
+      topic: normalizedFeed,
+      topicIndex: parentTopicIndex
+    });
     const commentCount = await client.getCommentCount(targetPost);
     if (commentCount === 0) {
       if (options.json) {
@@ -6362,7 +6616,11 @@ async function executeFeedCommentRead(feed, postId, options) {
     if (options.json) {
       printJson(
         commentsWithDepth.map(
-          ({ comment, depth }) => commentToJson(comment, depth)
+          ({ comment, depth }) => commentToJson(comment, {
+            chainId: readOnlyOptions.chainId,
+            depth,
+            parentPostUrl
+          })
         )
       );
     } else {
@@ -6503,8 +6761,10 @@ async function executeFeedReplies(options) {
     rpcUrl: options.rpcUrl
   });
   const client = createFeedClient(readOnlyOptions);
-  console.log(chalk4.blue(`Checking replies on ${postsWithIds.length} posts...
+  if (!options.json) {
+    console.log(chalk4.blue(`Checking replies on ${postsWithIds.length} posts...
 `));
+  }
   const results = [];
   for (const entry of postsWithIds) {
     try {
@@ -6519,12 +6779,31 @@ async function executeFeedReplies(options) {
         data: "0x"
       };
       const commentCount = await client.getCommentCount(postObj);
+      let permalink = null;
+      try {
+        const indices = await getMessageIndicesFromTx({
+          chainId: readOnlyOptions.chainId,
+          rpcUrl: readOnlyOptions.rpcUrl,
+          txHash: entry.txHash
+        });
+        if (indices[0] !== void 0) {
+          permalink = postPermalink(readOnlyOptions.chainId, {
+            globalIndex: indices[0]
+          });
+        }
+      } catch {
+      }
       results.push({
         feed: entry.feed,
         postId: entry.postId,
         text: entry.text ?? "",
         postedAt: entry.timestamp,
-        commentCount: Number(commentCount)
+        commentCount: Number(commentCount),
+        permalink,
+        feedUrl: feedUrl(readOnlyOptions.chainId, entry.feed),
+        senderProfileUrl: entry.sender ? profileUrl(readOnlyOptions.chainId, entry.sender) : null,
+        explorerTxUrl: explorerTxUrl(readOnlyOptions.chainId, entry.txHash),
+        txHash: entry.txHash
       });
     } catch {
     }
@@ -6609,7 +6888,14 @@ async function executeFeedPosts(address, options) {
       endIndex: count
     });
     if (options.json) {
-      printJson(messages.map((msg, i) => postToJson(msg, i)));
+      printJson(
+        messages.map(
+          (msg, i) => postToJson(msg, {
+            chainId: readOnlyOptions.chainId,
+            userIndex: startIndex + i
+          })
+        )
+      );
     } else {
       console.log(
         chalk4.white(`Found ${messages.length} post(s) by ${address}:
@@ -6787,11 +7073,14 @@ function historyEntryToJson(entry, index) {
     type: entry.type,
     timestamp: entry.timestamp,
     txHash: entry.txHash,
+    explorerTxUrl: explorerTxUrl(entry.chainId, entry.txHash),
     chainId: entry.chainId,
-    feed: entry.feed
+    feed: entry.feed,
+    feedUrl: feedUrl(entry.chainId, entry.feed)
   };
   if (entry.sender) {
     result.sender = entry.sender;
+    result.senderProfileUrl = profileUrl(entry.chainId, entry.sender);
   }
   if (entry.text) {
     result.text = entry.text;
@@ -6965,7 +7254,9 @@ async function executeListAgents(options) {
     if (options.json) {
       printJson({
         totalCount,
-        agents: agents.map((agent, i) => agentToJson(agent, i))
+        agents: agents.map(
+          (agent, i) => agentToJson(agent, i, readOnlyOptions.chainId)
+        )
       });
     } else {
       if (agents.length === 0) {
@@ -7024,9 +7315,13 @@ async function executeFeedVerifyClaim(txHash, options) {
   const netClient = createNetClient(readOnlyOptions);
   const existingHistory = getHistory();
   if (existingHistory.some((entry) => entry.txHash === txHash)) {
-    console.log(
-      chalk4.yellow("Transaction already recorded in history. Skipping.")
-    );
+    if (options.json) {
+      printJson({ alreadyRecorded: true, txHash });
+    } else {
+      console.log(
+        chalk4.yellow("Transaction already recorded in history. Skipping.")
+      );
+    }
     return;
   }
   const receipt = await publicClient.getTransactionReceipt({ hash: txHash }).catch(
@@ -7061,11 +7356,13 @@ async function executeFeedVerifyClaim(txHash, options) {
       "Transaction does not contain any Net protocol messages."
     );
   }
-  console.log(
-    chalk4.blue(
-      `Found ${messageSentEvents.length} message(s) in transaction. Fetching details...`
-    )
-  );
+  if (!options.json) {
+    console.log(
+      chalk4.blue(
+        `Found ${messageSentEvents.length} message(s) in transaction. Fetching details...`
+      )
+    );
+  }
   const messages = await Promise.all(
     messageSentEvents.map(
       (event) => netClient.getMessageAtIndex({
@@ -7073,41 +7370,40 @@ async function executeFeedVerifyClaim(txHash, options) {
       })
     )
   );
+  const entries = [];
   let recorded = 0;
   for (let i = 0; i < messages.length; i++) {
     const message = messages[i];
     if (!message) {
-      console.log(
-        chalk4.yellow(
-          `  Could not fetch message at index ${messageSentEvents[i].messageIndex}. Skipping.`
-        )
-      );
+      if (!options.json) {
+        console.log(
+          chalk4.yellow(
+            `  Could not fetch message at index ${messageSentEvents[i].messageIndex}. Skipping.`
+          )
+        );
+      }
       continue;
     }
+    const globalIndex = Number(messageSentEvents[i].messageIndex);
     const feedName = extractFeedName(message.topic);
     const isComment = isCommentTopic(message.topic);
     let type;
     let postId;
-    let label;
+    let parentPostId;
+    let permalink = null;
     if (isComment) {
       type = "comment";
       const commentData = parseCommentData(message.data);
-      postId = commentData ? `${commentData.parentSender}:${commentData.parentTimestamp}` : void 0;
-      label = `Verified comment:
-    Feed: ${feedName}
-    Sender: ${message.sender}
-    Text: ${message.text}
-    Parent post: ${postId ?? "unknown"}
-    Tx: ${txHash}`;
+      parentPostId = commentData ? `${commentData.parentSender}:${commentData.parentTimestamp}` : void 0;
+      const commentParam = `${message.sender}-${Number(message.timestamp)}`;
+      permalink = postPermalink(readOnlyOptions.chainId, {
+        globalIndex,
+        commentId: commentParam
+      });
     } else {
       type = "post";
       postId = createPostId(message);
-      label = `Verified post:
-    Feed: ${feedName}
-    Sender: ${message.sender}
-    Text: ${message.text}
-    Post ID: ${postId}
-    Tx: ${txHash}`;
+      permalink = postPermalink(readOnlyOptions.chainId, { globalIndex });
     }
     addHistoryEntry({
       type,
@@ -7116,11 +7412,49 @@ async function executeFeedVerifyClaim(txHash, options) {
       feed: feedName,
       sender: message.sender,
       text: message.text,
-      postId
+      postId: type === "comment" ? parentPostId : postId
     });
-    console.log(chalk4.green(`  ${label}`));
+    const entry = {
+      type,
+      txHash,
+      explorerTxUrl: explorerTxUrl(readOnlyOptions.chainId, txHash),
+      globalIndex,
+      permalink,
+      feed: feedName,
+      feedUrl: feedUrl(readOnlyOptions.chainId, feedName),
+      sender: message.sender,
+      senderProfileUrl: profileUrl(
+        readOnlyOptions.chainId,
+        message.sender
+      ),
+      text: message.text,
+      timestamp: Number(message.timestamp)
+    };
+    if (type === "post") entry.postId = postId;
+    if (type === "comment") entry.parentPostId = parentPostId;
+    entries.push(entry);
+    if (!options.json) {
+      const label = type === "comment" ? `Verified comment:
+    Feed: ${feedName}
+    Sender: ${message.sender}
+    Text: ${message.text}
+    Parent post: ${parentPostId ?? "unknown"}
+    Permalink: ${permalink ?? "(unavailable)"}
+    Tx: ${txHash}` : `Verified post:
+    Feed: ${feedName}
+    Sender: ${message.sender}
+    Text: ${message.text}
+    Post ID: ${postId}
+    Permalink: ${permalink ?? "(unavailable)"}
+    Tx: ${txHash}`;
+      console.log(chalk4.green(`  ${label}`));
+    }
     recorded++;
   }
+  if (options.json) {
+    printJson({ recorded, entries });
+    return;
+  }
   if (recorded > 0) {
     console.log(
       chalk4.green(`
@@ -7135,7 +7469,10 @@ function registerFeedVerifyClaimCommand(parent) {
     "--chain-id <id>",
     "Chain ID (default: 8453 for Base)",
     (value) => parseInt(value, 10)
-  ).option("--rpc-url <url>", "Custom RPC URL").action(async (txHash, options) => {
+  ).option("--rpc-url <url>", "Custom RPC URL").option(
+    "--json",
+    "Output structured JSON (includes permalink and other URLs)"
+  ).action(async (txHash, options) => {
     await executeFeedVerifyClaim(txHash, options);
   });
 }
@@ -7331,6 +7668,7 @@ async function executeGetUpvotes(options) {
         JSON.stringify(
           {
             tokenAddress,
+            tokenUrl: tokenUrl(readOnlyOptions.chainId, tokenAddress),
             scoreKey,
             total,
             strategies: strategyCounts.map((s) => ({
@@ -7499,6 +7837,8 @@ async function executeGetUserUpvotes(options) {
           {
             address: userAddress,
             chainId: readOnlyOptions.chainId,
+            profileUrl: profileUrl(readOnlyOptions.chainId, userAddress),
+            walletUrl: walletUrl(readOnlyOptions.chainId, userAddress),
             upvotesGiven: Number(given),
             upvotesReceived: Number(received),
             upvotePriceWei: upvotePrice.toString(),
@@ -7540,6 +7880,845 @@ function registerUpvoteCommand(program2) {
   registerUpvoteUserCommand(upvoteCommand);
   registerGetUserUpvotesCommand(upvoteCommand);
 }
+var VALID_RUN_MODES = ["auto", "feeds", "chats"];
+function addAuthOptions(cmd) {
+  return addCommonOptions(cmd).option("--private-key <key>", "Private key (0x-prefixed)").option(
+    "--session-token <token>",
+    "Pre-existing session token (alternative to --private-key)"
+  ).option(
+    "--operator <address>",
+    "Operator address (required with --session-token)"
+  );
+}
+function addCommonOptions(cmd) {
+  return cmd.option("--chain-id <id>", "Chain ID (default: 8453)", (v) => parseInt(v, 10)).option("--rpc-url <url>", "Custom RPC URL").option("--api-url <url>", "Net Protocol API URL");
+}
+function addFilterOptions(cmd) {
+  return cmd.option("--include-feed <pattern...>", "Only engage with matching feeds").option("--exclude-feed <pattern...>", "Never engage with matching feeds").option("--preferred-feed <pattern...>", "Prioritize matching feeds").option("--chat-topic <topic...>", "Chat topics to participate in");
+}
+function addProfileOptions(cmd) {
+  return cmd.option("--display-name <name>", "Agent display name").option("--bio <text>", "Agent bio");
+}
+function buildFilters(options) {
+  const filters = {};
+  if (options.includeFeed?.length) filters.includeFeedPatterns = options.includeFeed;
+  if (options.excludeFeed?.length) filters.excludeFeedPatterns = options.excludeFeed;
+  if (options.preferredFeed?.length) filters.preferredFeedPatterns = options.preferredFeed;
+  if (options.chatTopic?.length) filters.preferredChatTopics = options.chatTopic;
+  return Object.keys(filters).length > 0 ? filters : void 0;
+}
+function buildProfile(options) {
+  const profile = {};
+  if (options.displayName) profile.displayName = options.displayName;
+  if (options.bio) profile.bio = options.bio;
+  return Object.keys(profile).length > 0 ? profile : void 0;
+}
+function parseRunMode(raw) {
+  const mode = raw ?? "auto";
+  if (!VALID_RUN_MODES.includes(mode)) {
+    exitWithError(`Invalid mode "${mode}". Must be one of: ${VALID_RUN_MODES.join(", ")}`);
+  }
+  return mode;
+}
+function resolveReadOnly(options) {
+  const readOnly = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const apiUrl = options.apiUrl || process.env.NET_API_URL || NET_API_URL;
+  let operator;
+  if (options.operator) {
+    if (!isAddress(options.operator)) {
+      exitWithError(`Invalid operator address: ${options.operator}`);
+    }
+    operator = options.operator;
+  }
+  return { chainId: readOnly.chainId, apiUrl, operator };
+}
+async function resolveAuth(options) {
+  const sessionToken = options.sessionToken || process.env.NET_SESSION_TOKEN;
+  const privateKey = options.privateKey || process.env.NET_PRIVATE_KEY || process.env.PRIVATE_KEY;
+  if (sessionToken && options.privateKey) {
+    exitWithError("Cannot use both --session-token and --private-key. Pick one.");
+  }
+  const apiUrl = options.apiUrl || process.env.NET_API_URL || NET_API_URL;
+  if (sessionToken) {
+    if (!options.operator) {
+      exitWithError(
+        "--operator <address> is required when using --session-token. It must match the address that signed the session."
+      );
+    }
+    if (!isAddress(options.operator)) {
+      exitWithError(`Invalid operator address: ${options.operator}`);
+    }
+    const readOnly = parseReadOnlyOptionsWithDefault({
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const client2 = new AgentClient({ apiUrl, chainId: readOnly.chainId });
+    return {
+      client: client2,
+      sessionToken,
+      operatorAddress: options.operator,
+      chainId: readOnly.chainId,
+      apiUrl
+    };
+  }
+  if (!privateKey) {
+    exitWithError(
+      "No auth provided. Use one of:\n  --private-key <key> (or NET_PRIVATE_KEY env var)\n  --session-token <token> + --operator <address> (for Bankr or other external signers)"
+    );
+  }
+  const commonOptions = parseCommonOptionsWithDefault({
+    privateKey,
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const account = privateKeyToAccount(commonOptions.privateKey);
+  console.log(chalk4.blue("Creating session..."));
+  const { sessionToken: token } = await createRelaySession({
+    apiUrl,
+    chainId: commonOptions.chainId,
+    operatorAddress: account.address,
+    secretKey: RELAY_ACCESS_KEY,
+    account
+  });
+  const client = new AgentClient({ apiUrl, chainId: commonOptions.chainId });
+  return {
+    client,
+    sessionToken: token,
+    account,
+    operatorAddress: account.address,
+    chainId: commonOptions.chainId,
+    apiUrl
+  };
+}
+function bigintReplacer5(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+function jsonStringify(obj, indent = 2) {
+  return JSON.stringify(obj, bigintReplacer5, indent);
+}
+
+// src/commands/agent/create.ts
+async function executeCreate(name, options) {
+  try {
+    const auth = await resolveAuth(options);
+    const config = {
+      name,
+      systemPrompt: options.systemPrompt
+    };
+    if (options.schedule) config.runIntervalMinutes = options.schedule;
+    const filters = buildFilters(options);
+    if (filters) config.filters = filters;
+    const profile = buildProfile(options);
+    console.log(chalk4.blue(`Creating agent "${name}"...`));
+    const result = await auth.client.createAgent({
+      sessionToken: auth.sessionToken,
+      config,
+      profile
+    });
+    if (!result.success) {
+      exitWithError(result.error || "Failed to create agent");
+    }
+    if (options.json) {
+      console.log(jsonStringify(result));
+      return;
+    }
+    console.log(chalk4.green("Agent created successfully!"));
+    console.log(`  Agent ID: ${result.agentId}`);
+    console.log(`  Wallet:   ${result.agentWalletAddress}`);
+    if (result.scheduleError) {
+      console.log(chalk4.yellow(`  Schedule warning: ${result.scheduleError}`));
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to create agent: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerAgentCreateCommand(parent) {
+  const cmd = parent.command("create <name>").description("Create a new onchain agent").requiredOption("--system-prompt <prompt>", "Agent system prompt (personality)").option("--schedule <minutes>", "Auto-run interval in minutes", (v) => parseInt(v, 10)).option("--json", "Output as JSON");
+  addAuthOptions(cmd);
+  addFilterOptions(cmd);
+  addProfileOptions(cmd);
+  cmd.action(async (name, options) => {
+    await executeCreate(name, options);
+  });
+}
+async function executeList(options) {
+  try {
+    const auth = await resolveAuth(options);
+    const result = await auth.client.listAgents({ sessionToken: auth.sessionToken });
+    if (!result.success) {
+      exitWithError(result.error || "Failed to list agents");
+    }
+    const agents = result.agents || [];
+    const visible = options.showHidden ? agents : agents.filter((a) => !a.config.hidden);
+    if (options.json) {
+      console.log(jsonStringify(visible));
+      return;
+    }
+    if (visible.length === 0) {
+      console.log(chalk4.yellow("No agents found."));
+      return;
+    }
+    console.log(chalk4.bold(`Agents (${visible.length}):
+`));
+    for (const agent of visible) {
+      const { config, walletAddress } = agent;
+      const schedule = config.runIntervalMinutes ? `every ${config.runIntervalMinutes}m` : "manual";
+      const hidden = config.hidden ? chalk4.gray(" [hidden]") : "";
+      const promptPreview = config.systemPrompt.length > 80 ? `${config.systemPrompt.slice(0, 80)}...` : config.systemPrompt;
+      console.log(`  ${chalk4.cyan(config.name)}${hidden}`);
+      console.log(`    ID:       ${config.id}`);
+      console.log(`    Wallet:   ${walletAddress}`);
+      console.log(`    Schedule: ${schedule}`);
+      console.log(`    Prompt:   ${promptPreview}`);
+      console.log();
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to list agents: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerAgentListCommand(parent) {
+  const cmd = parent.command("list").description("List your onchain agents").option("--json", "Output as JSON").option("--show-hidden", "Include hidden agents");
+  addAuthOptions(cmd);
+  cmd.action(async (options) => {
+    await executeList(options);
+  });
+}
+async function executeUpdate(agentId, options) {
+  try {
+    const auth = await resolveAuth(options);
+    const config = {};
+    let hasConfigChanges = false;
+    if (options.name) {
+      config.name = options.name;
+      hasConfigChanges = true;
+    }
+    if (options.systemPrompt) {
+      config.systemPrompt = options.systemPrompt;
+      hasConfigChanges = true;
+    }
+    if (options.schedule) {
+      config.runIntervalMinutes = options.schedule;
+      hasConfigChanges = true;
+    }
+    if (options.disableSchedule) {
+      config.runIntervalMinutes = 0;
+      hasConfigChanges = true;
+    }
+    const filters = buildFilters(options);
+    if (filters) {
+      config.filters = filters;
+      hasConfigChanges = true;
+    }
+    const profile = buildProfile(options);
+    if (!hasConfigChanges && !profile) {
+      exitWithError(
+        "No changes specified. Use --name, --system-prompt, --schedule, --display-name, --bio, or filter options."
+      );
+    }
+    console.log(chalk4.blue(`Updating agent ${agentId}...`));
+    const result = await auth.client.updateAgent({
+      sessionToken: auth.sessionToken,
+      agentId,
+      config: hasConfigChanges ? config : void 0,
+      profile
+    });
+    if (!result.success) {
+      exitWithError(result.error || "Failed to update agent");
+    }
+    if (options.json) {
+      console.log(jsonStringify(result));
+      return;
+    }
+    console.log(chalk4.green("Agent updated successfully!"));
+    if (result.profileError) {
+      console.log(chalk4.yellow(`  Profile warning: ${result.profileError}`));
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to update agent: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerAgentUpdateCommand(parent) {
+  const cmd = parent.command("update <agentId>").description("Update an existing agent").option("--name <name>", "New agent name").option("--system-prompt <prompt>", "New system prompt").option("--schedule <minutes>", "Auto-run interval in minutes", (v) => parseInt(v, 10)).option("--disable-schedule", "Disable automatic scheduling").option("--json", "Output as JSON");
+  addAuthOptions(cmd);
+  addFilterOptions(cmd);
+  addProfileOptions(cmd);
+  cmd.action(async (agentId, options) => {
+    await executeUpdate(agentId, options);
+  });
+}
+async function executeToggleHidden(agentId, options, hide) {
+  const verb = hide ? "Hiding" : "Unhiding";
+  const past = hide ? "hidden" : "unhidden";
+  try {
+    const auth = await resolveAuth(options);
+    console.log(chalk4.blue(`${verb} agent ${agentId}...`));
+    const result = hide ? await auth.client.hideAgent(auth.sessionToken, agentId) : await auth.client.unhideAgent(auth.sessionToken, agentId);
+    if (!result.success) {
+      exitWithError(result.error || `Failed to ${hide ? "hide" : "unhide"} agent`);
+    }
+    console.log(chalk4.green(`Agent ${past} successfully.`));
+  } catch (error) {
+    exitWithError(
+      `Failed to ${hide ? "hide" : "unhide"} agent: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerAgentHideCommand(parent) {
+  const cmd = parent.command("hide <agentId>").description("Hide an agent (soft-delete)");
+  addAuthOptions(cmd).action(async (agentId, options) => {
+    await executeToggleHidden(agentId, options, true);
+  });
+}
+function registerAgentUnhideCommand(parent) {
+  const cmd = parent.command("unhide <agentId>").description("Unhide a previously hidden agent");
+  addAuthOptions(cmd).action(async (agentId, options) => {
+    await executeToggleHidden(agentId, options, false);
+  });
+}
+async function executeRun(agentId, options) {
+  try {
+    const auth = await resolveAuth(options);
+    const mode = parseRunMode(options.mode);
+    console.log(chalk4.blue(`Running agent ${agentId} (mode: ${mode})...`));
+    const result = await auth.client.runAgent({
+      sessionToken: auth.sessionToken,
+      agentId,
+      mode
+    });
+    if (options.json) {
+      console.log(jsonStringify(result));
+      return;
+    }
+    if (!result.success) {
+      exitWithError(result.error || "Agent run failed");
+    }
+    console.log(chalk4.green(`Agent run complete: ${result.action}`));
+    if (result.summary) {
+      console.log(`  Summary: ${result.summary}`);
+    }
+    if (result.actions.length > 0) {
+      console.log("  Actions:");
+      for (const action of result.actions) {
+        const textPreview = action.text.length > 60 ? `${action.text.slice(0, 60)}...` : action.text;
+        console.log(`    - ${action.type} in ${action.topic}: "${textPreview}"`);
+        console.log(`      tx: ${action.transactionHash}`);
+      }
+    }
+    if (result.autoFunded) {
+      console.log(
+        chalk4.blue(
+          `  Auto-funded: $${result.autoFunded.amountUsd.toFixed(4)} (${result.autoFunded.amountEth} ETH)`
+        )
+      );
+    }
+    if (result.agentBalanceUsd !== void 0) {
+      console.log(`  Agent balance: $${result.agentBalanceUsd.toFixed(4)}`);
+    }
+    if (result.mainBalanceUsd !== void 0) {
+      console.log(`  Credits balance: $${result.mainBalanceUsd.toFixed(4)}`);
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to run agent: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerAgentRunCommand(parent) {
+  const cmd = parent.command("run <agentId>").description("Execute one agent cycle").option("--mode <mode>", "Run mode: auto, feeds, or chats (default: auto)").option("--json", "Output as JSON");
+  addAuthOptions(cmd).action(async (agentId, options) => {
+    await executeRun(agentId, options);
+  });
+}
+async function executeInfo(agentId, options) {
+  try {
+    const auth = await resolveAuth(options);
+    const agent = await auth.client.getAgent(auth.sessionToken, agentId);
+    if (!agent) {
+      exitWithError(`Agent not found: ${agentId}`);
+      return;
+    }
+    if (options.json) {
+      console.log(jsonStringify(agent));
+      return;
+    }
+    const { config, walletAddress } = agent;
+    const schedule = config.runIntervalMinutes ? `every ${config.runIntervalMinutes} minutes` : "manual only";
+    console.log(
+      chalk4.bold(config.name) + (config.hidden ? chalk4.gray(" [hidden]") : "")
+    );
+    console.log();
+    console.log(`  ID:           ${config.id}`);
+    console.log(`  Wallet:       ${walletAddress}`);
+    console.log(`  Owner:        ${config.ownerAddress}`);
+    console.log(`  Schedule:     ${schedule}`);
+    console.log(`  Created:      ${new Date(config.createdAt).toLocaleString()}`);
+    console.log(`  Updated:      ${new Date(config.updatedAt).toLocaleString()}`);
+    console.log();
+    console.log("  System Prompt:");
+    console.log(`    ${config.systemPrompt}`);
+    if (config.filters) {
+      console.log();
+      console.log("  Filters:");
+      if (config.filters.includeFeedPatterns?.length) {
+        console.log(`    Include feeds: ${config.filters.includeFeedPatterns.join(", ")}`);
+      }
+      if (config.filters.excludeFeedPatterns?.length) {
+        console.log(`    Exclude feeds: ${config.filters.excludeFeedPatterns.join(", ")}`);
+      }
+      if (config.filters.preferredFeedPatterns?.length) {
+        console.log(
+          `    Preferred feeds: ${config.filters.preferredFeedPatterns.join(", ")}`
+        );
+      }
+      if (config.filters.preferredChatTopics?.length) {
+        console.log(`    Chat topics: ${config.filters.preferredChatTopics.join(", ")}`);
+      }
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to get agent info: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerAgentInfoCommand(parent) {
+  const cmd = parent.command("info <agentId>").description("Show detailed agent information").option("--json", "Output as JSON");
+  addAuthOptions(cmd).action(async (agentId, options) => {
+    await executeInfo(agentId, options);
+  });
+}
+async function executeDm(agentAddress, message, options) {
+  try {
+    if (!isAddress(agentAddress)) {
+      exitWithError(`Invalid agent address: ${agentAddress}`);
+    }
+    if (options.topicSignature && !options.topic) {
+      exitWithError(
+        "--topic-signature requires --topic (the topic the signature authorizes)"
+      );
+    }
+    const usingSessionToken = !!(options.sessionToken || process.env.NET_SESSION_TOKEN);
+    if (usingSessionToken && (!options.topic || !options.topicSignature)) {
+      exitWithError(
+        "When using --session-token, you must also provide --topic and --topic-signature.\n  Obtain the signature with:\n    netp agent dm-auth-encode --agent-address <addr>  \u2192 produces { typedData, topic }\n    [sign .typedData with your external signer, e.g. Bankr /agent/sign]\n  Then:\n    netp agent dm <addr> <message> --session-token <token> --operator <addr> \\\n      --topic <topic> --topic-signature <sig>"
+      );
+    }
+    const auth = await resolveAuth(options);
+    const topic = options.topic ?? generateAgentChatTopic(agentAddress);
+    const isNewConversation = !options.topic;
+    console.log(
+      chalk4.blue(
+        isNewConversation ? `Starting new conversation with ${agentAddress}...` : `Continuing conversation ${topic}...`
+      )
+    );
+    const result = await auth.client.sendMessage(
+      {
+        sessionToken: auth.sessionToken,
+        agentAddress,
+        topic,
+        message,
+        userSignature: options.topicSignature
+      },
+      auth.account
+    );
+    if (options.json) {
+      console.log(jsonStringify(result));
+      return;
+    }
+    console.log();
+    console.log(chalk4.cyan("You: ") + message);
+    console.log(chalk4.green("Agent: ") + result.aiMessage);
+    console.log();
+    console.log(chalk4.gray(`  Topic: ${result.topic}`));
+    console.log(chalk4.gray(`  TX: ${result.transactionHash}`));
+    if (isNewConversation) {
+      console.log(
+        chalk4.gray(`  (Use --topic ${result.topic} to continue this conversation)`)
+      );
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to send DM: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerAgentDmCommand(parent) {
+  const cmd = parent.command("dm <agentAddress> <message>").description("Send a DM to an onchain agent").option("--topic <topic>", "Continue an existing conversation").option(
+    "--topic-signature <hex>",
+    "Pre-signed ConversationAuth signature (requires --topic). Obtain via `agent dm-auth-encode` + external signer."
+  ).option("--json", "Output as JSON");
+  addAuthOptions(cmd).action(async (agentAddress, message, options) => {
+    await executeDm(agentAddress, message, options);
+  });
+}
+async function executeDmList(options) {
+  try {
+    const { chainId, apiUrl, operator } = resolveReadOnly(options);
+    if (!operator) {
+      exitWithError(
+        "--operator <address> is required (user wallet address to list conversations for)"
+      );
+    }
+    const client = new AgentClient({ apiUrl, chainId });
+    console.log(chalk4.blue("Loading conversations..."));
+    const conversations = await client.listConversations(operator, {
+      limit: options.limit
+    });
+    const agentConversations = conversations.filter((c) => isAgentChatTopic(c.topic));
+    if (options.json) {
+      console.log(jsonStringify(agentConversations));
+      return;
+    }
+    if (agentConversations.length === 0) {
+      console.log(chalk4.yellow("No agent conversations found."));
+      return;
+    }
+    console.log(chalk4.bold(`Agent Conversations (${agentConversations.length}):
+`));
+    for (const conv of agentConversations) {
+      const agentAddr = parseAgentAddressFromTopic(conv.topic);
+      const encrypted = conv.isEncrypted ? chalk4.yellow(" [encrypted]") : "";
+      const date = new Date(conv.lastMessageTimestamp * 1e3).toLocaleString();
+      const preview = conv.lastMessage ? conv.lastMessage.length > 60 ? `${conv.lastMessage.slice(0, 60)}...` : conv.lastMessage : null;
+      console.log(`  ${chalk4.cyan(agentAddr || "unknown")}${encrypted}`);
+      console.log(`    Topic:    ${conv.topic}`);
+      console.log(`    Messages: ${conv.messageCount}`);
+      console.log(`    Last:     ${date}`);
+      if (preview) console.log(`    Preview:  ${preview}`);
+      console.log();
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to list conversations: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerAgentDmListCommand(parent) {
+  const cmd = parent.command("dm-list").description("List your DM conversations with agents (pure chain read)").requiredOption("--operator <address>", "User wallet address").option("--limit <n>", "Max conversations to fetch", (v) => parseInt(v, 10)).option("--json", "Output as JSON");
+  addCommonOptions(cmd).action(async (options) => {
+    await executeDmList(options);
+  });
+}
+async function executeDmHistory(topic, options) {
+  try {
+    const { chainId, apiUrl, operator } = resolveReadOnly(options);
+    if (!operator) {
+      exitWithError(
+        "--operator <address> is required (user wallet address for this conversation)"
+      );
+    }
+    const client = new AgentClient({ apiUrl, chainId });
+    console.log(chalk4.blue("Loading conversation history..."));
+    const messages = await client.getConversationHistory(operator, topic, {
+      limit: options.limit
+    });
+    if (options.json) {
+      console.log(jsonStringify(messages));
+      return;
+    }
+    if (messages.length === 0) {
+      console.log(chalk4.yellow("No messages found."));
+      return;
+    }
+    const agentAddr = parseAgentAddressFromTopic(topic);
+    console.log(
+      chalk4.bold(
+        `Conversation with ${agentAddr || topic} (${messages.length} messages):
+`
+      )
+    );
+    for (const msg of messages) {
+      const date = new Date(msg.timestamp * 1e3).toLocaleString();
+      const prefix = msg.sender === "user" ? chalk4.cyan("You") : chalk4.green("Agent");
+      const encrypted = msg.encrypted ? chalk4.yellow(" [encrypted]") : "";
+      console.log(`  ${prefix}${encrypted} (${chalk4.gray(date)}):`);
+      console.log(`    ${msg.text}`);
+      console.log();
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to load history: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerAgentDmHistoryCommand(parent) {
+  const cmd = parent.command("dm-history <topic>").description("Read DM conversation history (pure chain read)").requiredOption(
+    "--operator <address>",
+    "User wallet address for this conversation"
+  ).option("--limit <n>", "Max recent messages to fetch", (v) => parseInt(v, 10)).option("--json", "Output as JSON");
+  addCommonOptions(cmd).action(async (topic, options) => {
+    await executeDmHistory(topic, options);
+  });
+}
+async function executeDmAuthEncode(options) {
+  try {
+    const { chainId } = parseReadOnlyOptionsWithDefault({
+      chainId: options.chainId
+    });
+    let topic = options.topic;
+    if (!topic) {
+      if (!options.agentAddress) {
+        exitWithError(
+          "Must provide either --topic or --agent-address to generate a topic"
+        );
+      }
+      if (!isAddress(options.agentAddress)) {
+        exitWithError(`Invalid agent address: ${options.agentAddress}`);
+      }
+      topic = generateAgentChatTopic(options.agentAddress);
+    }
+    const result = buildConversationAuthTypedData({ topic, chainId });
+    console.log(jsonStringify(result));
+  } catch (error) {
+    exitWithError(
+      `dm-auth-encode failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerAgentDmAuthEncodeCommand(parent) {
+  parent.command("dm-auth-encode").description(
+    "Emit { typedData, topic } for external signing. Pipe .typedData to your signer, pass .topic + the resulting signature to `agent dm --topic ... --topic-signature ...`."
+  ).option(
+    "--topic <topic>",
+    "Existing topic to authorize (e.g. agent-chat-0x...-nanoid). If omitted, a new topic is generated from --agent-address."
+  ).option(
+    "--agent-address <address>",
+    "Agent address \u2014 used to generate a new topic when --topic is omitted"
+  ).option("--chain-id <id>", "Chain ID (default: 8453)", (v) => parseInt(v, 10)).action(async (options) => {
+    await executeDmAuthEncode(options);
+  });
+}
+async function executeSessionEncode(options) {
+  try {
+    if (!isAddress(options.operator)) {
+      exitWithError(`Invalid operator address: ${options.operator}`);
+    }
+    const { chainId } = parseReadOnlyOptionsWithDefault({
+      chainId: options.chainId
+    });
+    const result = buildSessionTypedData({
+      operatorAddress: options.operator,
+      chainId,
+      expiresIn: options.expiresIn
+    });
+    console.log(jsonStringify(result));
+  } catch (error) {
+    exitWithError(
+      `session-encode failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerAgentSessionEncodeCommand(parent) {
+  parent.command("session-encode").description(
+    "Emit { typedData, expiresAt } for external signing (e.g., Bankr). Pipe .typedData to your signer, pass .expiresAt + the resulting signature to `agent session-create`."
+  ).requiredOption(
+    "--operator <address>",
+    "Address that will sign the session (must match signer)"
+  ).option("--chain-id <id>", "Chain ID (default: 8453)", (v) => parseInt(v, 10)).option(
+    "--expires-in <seconds>",
+    "Session lifetime in seconds (default: 3600, max: 86400)",
+    (v) => parseInt(v, 10)
+  ).action(async (options) => {
+    await executeSessionEncode(options);
+  });
+}
+async function executeSessionCreate(options) {
+  try {
+    if (!isAddress(options.operator)) {
+      exitWithError(`Invalid operator address: ${options.operator}`);
+    }
+    if (!options.signature.startsWith("0x")) {
+      exitWithError("--signature must be a 0x-prefixed hex string");
+    }
+    if (!options.expiresAt || !Number.isFinite(options.expiresAt)) {
+      exitWithError("--expires-at must be a unix timestamp (seconds)");
+    }
+    const { chainId } = parseReadOnlyOptionsWithDefault({
+      chainId: options.chainId
+    });
+    const apiUrl = options.apiUrl || process.env.NET_API_URL || NET_API_URL;
+    const result = await exchangeSessionSignature({
+      apiUrl,
+      chainId,
+      operatorAddress: options.operator,
+      signature: options.signature,
+      expiresAt: options.expiresAt
+    });
+    console.log(jsonStringify(result));
+  } catch (error) {
+    exitWithError(
+      `session-create failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerAgentSessionCreateCommand(parent) {
+  parent.command("session-create").description(
+    "Exchange an externally-produced signature for a session token. Pair with `agent session-encode`."
+  ).requiredOption(
+    "--operator <address>",
+    "Address that produced the signature (must match the ecrecover result)"
+  ).requiredOption("--signature <hex>", "EIP-712 signature over the session typed data").requiredOption(
+    "--expires-at <timestamp>",
+    "expiresAt value from session-encode (unix seconds)",
+    (v) => parseInt(v, 10)
+  ).option("--chain-id <id>", "Chain ID (default: 8453)", (v) => parseInt(v, 10)).option("--api-url <url>", "Net Protocol API URL").action(async (options) => {
+    await executeSessionCreate(options);
+  });
+}
+
+// src/commands/agent/index.ts
+function registerAgentCommand(program2) {
+  const agentCommand = program2.command("agent").description("Onchain agent operations (create, manage, run, DM)");
+  registerAgentCreateCommand(agentCommand);
+  registerAgentListCommand(agentCommand);
+  registerAgentUpdateCommand(agentCommand);
+  registerAgentHideCommand(agentCommand);
+  registerAgentUnhideCommand(agentCommand);
+  registerAgentRunCommand(agentCommand);
+  registerAgentInfoCommand(agentCommand);
+  registerAgentDmCommand(agentCommand);
+  registerAgentDmListCommand(agentCommand);
+  registerAgentDmHistoryCommand(agentCommand);
+  registerAgentSessionEncodeCommand(agentCommand);
+  registerAgentSessionCreateCommand(agentCommand);
+  registerAgentDmAuthEncodeCommand(agentCommand);
+}
+var CHAINS = {
+  8453: base,
+  84532: baseSepolia
+};
+function getApiUrl(chainId) {
+  return chainId === 84532 ? NET_TESTNET_API_URL : NET_API_URL;
+}
+function registerRelayCommand(program2) {
+  const relayCommand = program2.command("relay").description("Relay operations (fund credits, check balance)");
+  relayCommand.command("fund").description("Add Net credits via x402 USDC payment").option("--amount <usd>", "Amount in USD to fund (default: 0.10)", "0.10").option("--chain-id <id>", "Chain ID (default: 8453)").option("--rpc-url <url>", "Custom RPC URL").option("--private-key <key>", "Private key (0x-prefixed)").option("--json", "Output as JSON").action(async (options) => {
+    const { privateKey, chainId, rpcUrl } = parseCommonOptionsWithDefault({
+      privateKey: options.privateKey,
+      chainId: options.chainId ? parseInt(options.chainId, 10) : void 0,
+      rpcUrl: options.rpcUrl
+    });
+    const amount = parseFloat(options.amount);
+    if (isNaN(amount) || amount <= 0) {
+      exitWithError("Invalid amount. Must be a positive number.");
+    }
+    const chain = CHAINS[chainId];
+    if (!chain) {
+      exitWithError(
+        `Chain ${chainId} not supported for relay funding. Use Base (8453) or Base Sepolia (84532).`
+      );
+    }
+    const account = privateKeyToAccount(privateKey);
+    const rpcUrls = getChainRpcUrls({ chainId, rpcUrl });
+    const publicClient = createPublicClient({
+      chain,
+      transport: http(rpcUrls[0])
+    });
+    const walletClient = createWalletClient({
+      account,
+      chain,
+      transport: http(rpcUrls[0])
+    });
+    const signer = {
+      address: account.address,
+      signTypedData: (msg) => walletClient.signTypedData(msg),
+      readContract: (args) => publicClient.readContract(args),
+      sendTransaction: (args) => walletClient.sendTransaction(args)
+    };
+    const { x402Client, wrapFetchWithPayment, x402HTTPClient } = await import('@x402/fetch');
+    const { registerExactEvmScheme } = await import('@x402/evm/exact/client');
+    const client = new x402Client();
+    registerExactEvmScheme(client, { signer });
+    const fetchWithPayment = wrapFetchWithPayment(fetch, client);
+    const httpClient = new x402HTTPClient(client);
+    const apiUrl = getApiUrl(chainId);
+    if (!options.json) {
+      console.log(
+        `Funding $${amount.toFixed(2)} USDC to relay on chain ${chainId}...`
+      );
+    }
+    try {
+      const result = await fundBackendWallet({
+        apiUrl,
+        chainId,
+        operatorAddress: account.address,
+        secretKey: RELAY_ACCESS_KEY,
+        fetchWithPayment,
+        httpClient,
+        amount
+      });
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              success: true,
+              paymentTxHash: result.paymentTxHash,
+              backendWalletAddress: result.backendWalletAddress,
+              amountUsd: amount
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        console.log(chalk4.green(`
+\u2713 Funded $${amount.toFixed(2)} successfully`));
+        console.log(`  Payment tx: ${result.paymentTxHash}`);
+        console.log(
+          `  Backend wallet: ${result.backendWalletAddress}`
+        );
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, error: msg }, null, 2));
+        process.exit(1);
+      }
+      exitWithError(`Funding failed: ${msg}`);
+    }
+  });
+  relayCommand.command("balance").description("Check relay backend wallet balance").option("--chain-id <id>", "Chain ID (default: 8453)").option("--private-key <key>", "Private key (0x-prefixed)").option("--json", "Output as JSON").action(async (options) => {
+    const { privateKey, chainId } = parseCommonOptionsWithDefault({
+      privateKey: options.privateKey,
+      chainId: options.chainId ? parseInt(options.chainId, 10) : void 0
+    });
+    const account = privateKeyToAccount(privateKey);
+    const apiUrl = getApiUrl(chainId);
+    try {
+      const result = await checkBackendWalletBalance({
+        apiUrl,
+        chainId,
+        operatorAddress: account.address,
+        secretKey: RELAY_ACCESS_KEY
+      });
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(`Relay Balance`);
+        console.log(`  Backend wallet: ${result.backendWalletAddress}`);
+        console.log(`  Balance: ${result.balanceEth} ETH`);
+        console.log(
+          `  Sufficient: ${result.sufficientBalance ? chalk4.green("Yes") : chalk4.red("No")} (min: ${result.minRequiredEth} ETH)`
+        );
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, error: msg }, null, 2));
+        process.exit(1);
+      }
+      exitWithError(`Balance check failed: ${msg}`);
+    }
+  });
+}
 var CACHE_DIR = join(homedir(), ".netp");
 var CACHE_FILE = join(CACHE_DIR, "update-check.json");
 var CHECK_INTERVAL_MS = 4 * 60 * 60 * 1e3;
@@ -7640,6 +8819,8 @@ registerProfileCommand(program);
 registerBazaarCommand(program);
 registerFeedCommand(program);
 registerUpvoteCommand(program);
+registerAgentCommand(program);
+registerRelayCommand(program);
 program.command("update").description("Update netp to the latest version").action(async () => {
   const { execSync } = await import('child_process');
   console.log("Updating @net-protocol/cli...");