@net-protocol/cli 0.1.41 → 0.1.43

package/dist/cli/index.mjs

@@ -7,15 +7,15 @@ 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 { createPublicClient, http, createWalletClient, stringToHex, hexToString, parseEther, encodeFunctionData, publicActions, concat, defineChain, decodeEventLog, formatEther, isAddress } from 'viem';
 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 { getNetContract, getChainName, getChainRpcUrls, getPublicClient, getBaseDataSuffix, NetClient, toBytes32, NULL_ADDRESS } from '@net-protocol/core';
+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) {
@@ -1566,8 +1567,8 @@ 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 { privateKeyToAccount: privateKeyToAccount28 } = await import('viem/accounts');
+      const userAccount = privateKeyToAccount28(commonOptions.privateKey);
       const storageUrl = generateStorageUrl(
         userAccount.address,
         commonOptions.chainId,
@@ -2369,6 +2370,7 @@ async function executeProfileGet(options) {
     }
     let xUsername;
     let bio;
+    let displayName;
     let tokenAddress;
     try {
       const metadataResult = await client.readStorageData({
@@ -2379,6 +2381,7 @@ async function executeProfileGet(options) {
         const metadata = parseProfileMetadata(metadataResult.data);
         xUsername = metadata?.x_username;
         bio = metadata?.bio;
+        displayName = metadata?.display_name;
         tokenAddress = metadata?.token_address;
       }
     } catch (error) {
@@ -2419,12 +2422,13 @@ async function executeProfileGet(options) {
         throw error;
       }
     }
-    const hasProfile = profilePicture || xUsername || bio || tokenAddress || canvasSize || cssSize;
+    const hasProfile = profilePicture || xUsername || bio || displayName || tokenAddress || canvasSize || cssSize;
     if (options.json) {
       const output = {
         address: options.address,
         chainId: readOnlyOptions.chainId,
         profilePicture: profilePicture || null,
+        displayName: displayName || null,
         xUsername: xUsername || null,
         bio: bio || null,
         tokenAddress: tokenAddress || null,
@@ -2438,6 +2442,9 @@ async function executeProfileGet(options) {
     console.log(chalk4.white.bold("\nProfile:\n"));
     console.log(`  ${chalk4.cyan("Address:")} ${options.address}`);
     console.log(`  ${chalk4.cyan("Chain ID:")} ${readOnlyOptions.chainId}`);
+    console.log(
+      `  ${chalk4.cyan("Display Name:")} ${displayName || chalk4.gray("(not set)")}`
+    );
     console.log(
       `  ${chalk4.cyan("Profile Picture:")} ${profilePicture || chalk4.gray("(not set)")}`
     );
@@ -7534,6 +7541,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;
@@ -7634,6 +8480,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...");