@net-protocol/cli 0.1.12 → 0.1.14

package/dist/feed/index.mjs

@@ -0,0 +1,1357 @@
+import chalk12 from 'chalk';
+import { FeedRegistryClient, FeedClient } from '@net-protocol/feeds';
+import { NULL_ADDRESS, getChainRpcUrls, NetClient } from '@net-protocol/core';
+import '@net-protocol/storage';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { encodeFunctionData, createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import * as readline from 'readline';
+
+// src/commands/feed/list.ts
+var DEFAULT_CHAIN_ID = 8453;
+function getChainIdWithDefault(optionValue) {
+  if (optionValue) {
+    return optionValue;
+  }
+  const envChainId = process.env.BOTCHAN_CHAIN_ID || process.env.NET_CHAIN_ID;
+  if (envChainId) {
+    return parseInt(envChainId, 10);
+  }
+  return DEFAULT_CHAIN_ID;
+}
+function getRpcUrlWithBotchanFallback(optionValue) {
+  return optionValue || process.env.BOTCHAN_RPC_URL || process.env.NET_RPC_URL;
+}
+function parseReadOnlyOptionsWithDefault(options) {
+  return {
+    chainId: getChainIdWithDefault(options.chainId),
+    rpcUrl: getRpcUrlWithBotchanFallback(options.rpcUrl)
+  };
+}
+function parseCommonOptionsWithDefault(options, supportsEncodeOnly = false) {
+  const privateKey = options.privateKey || process.env.BOTCHAN_PRIVATE_KEY || process.env.NET_PRIVATE_KEY || process.env.PRIVATE_KEY;
+  if (!privateKey) {
+    const encodeOnlyHint = supportsEncodeOnly ? ", or use --encode-only to output transaction data without submitting" : "";
+    console.error(
+      chalk12.red(
+        `Error: Private key is required. Provide via --private-key flag or NET_PRIVATE_KEY/BOTCHAN_PRIVATE_KEY environment variable${encodeOnlyHint}`
+      )
+    );
+    process.exit(1);
+  }
+  if (!privateKey.startsWith("0x") || privateKey.length !== 66) {
+    console.error(
+      chalk12.red(
+        "Error: Invalid private key format (must be 0x-prefixed, 66 characters)"
+      )
+    );
+    process.exit(1);
+  }
+  if (options.privateKey) {
+    console.warn(
+      chalk12.yellow(
+        "Warning: Private key provided via command line. Consider using NET_PRIVATE_KEY environment variable instead."
+      )
+    );
+  }
+  return {
+    privateKey,
+    chainId: getChainIdWithDefault(options.chainId),
+    rpcUrl: getRpcUrlWithBotchanFallback(options.rpcUrl)
+  };
+}
+function createFeedClient(options) {
+  return new FeedClient({
+    chainId: options.chainId,
+    overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+  });
+}
+function createFeedRegistryClient(options) {
+  return new FeedRegistryClient({
+    chainId: options.chainId,
+    overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+  });
+}
+function createNetClient(options) {
+  return new NetClient({
+    chainId: options.chainId,
+    overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+  });
+}
+function exitWithError(message) {
+  console.error(chalk12.red(`Error: ${message}`));
+  process.exit(1);
+}
+function truncateAddress(address) {
+  if (address.length <= 12) return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function formatTimestamp(timestamp) {
+  return new Date(Number(timestamp) * 1e3).toISOString().replace("T", " ").slice(0, 19);
+}
+function parseTopic(topic) {
+  const commentMatch = topic.match(/^(.+?):comments:/);
+  if (commentMatch) {
+    return { feedName: commentMatch[1], isComment: true };
+  }
+  return { feedName: topic, isComment: false };
+}
+function formatPost(post, index, options = {}) {
+  const { commentCount, showTopic } = options;
+  const timestamp = formatTimestamp(post.timestamp);
+  const lines = [
+    chalk12.cyan(`[${index}]`) + ` ${chalk12.gray(timestamp)}`,
+    `  ${chalk12.white("Sender:")} ${post.sender}`,
+    `  ${chalk12.white("Text:")} ${post.text}`
+  ];
+  if (showTopic && post.topic) {
+    const { feedName, isComment } = parseTopic(post.topic);
+    const prefix = isComment ? "Comment on" : "Feed";
+    lines.push(`  ${chalk12.white(prefix + ":")} ${chalk12.magenta(feedName)}`);
+  }
+  if (commentCount !== void 0) {
+    lines.push(`  ${chalk12.white("Comments:")} ${commentCount}`);
+  }
+  if (post.data && post.data !== "0x") {
+    lines.push(`  ${chalk12.white("Data:")} ${post.data}`);
+  }
+  return lines.join("\n");
+}
+function formatFeed(feed, index) {
+  const timestamp = formatTimestamp(feed.timestamp);
+  const lines = [
+    chalk12.cyan(`[${index}]`) + ` ${chalk12.white(feed.feedName)}`,
+    `    ${chalk12.gray("Registrant:")} ${feed.registrant}`,
+    `    ${chalk12.gray("Registered:")} ${timestamp}`
+  ];
+  return lines.join("\n");
+}
+function formatComment(comment, depth) {
+  const indent = "  ".repeat(depth + 1);
+  const timestamp = formatTimestamp(comment.timestamp);
+  const lines = [
+    `${indent}${chalk12.gray(timestamp)} ${chalk12.blue(truncateAddress(comment.sender))}`,
+    `${indent}${comment.text}`
+  ];
+  return lines.join("\n");
+}
+function postToJson(post, index, commentCount) {
+  const result = {
+    index,
+    sender: post.sender,
+    text: post.text,
+    timestamp: Number(post.timestamp),
+    topic: post.topic
+  };
+  if (commentCount !== void 0) {
+    result.commentCount = commentCount;
+  }
+  if (post.data && post.data !== "0x") {
+    result.data = post.data;
+  }
+  return result;
+}
+function feedToJson(feed, index) {
+  return {
+    index,
+    feedName: feed.feedName,
+    registrant: feed.registrant,
+    timestamp: feed.timestamp
+  };
+}
+function commentToJson(comment, depth) {
+  return {
+    sender: comment.sender,
+    text: comment.text,
+    timestamp: Number(comment.timestamp),
+    depth,
+    data: comment.data !== "0x" ? comment.data : void 0
+  };
+}
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+// src/commands/feed/list.ts
+async function executeFeedList(options) {
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createFeedRegistryClient(readOnlyOptions);
+  try {
+    const feeds = await client.getRegisteredFeeds({
+      maxFeeds: options.limit ?? 50
+    });
+    if (options.json) {
+      printJson(feeds.map((feed, i) => feedToJson(feed, i)));
+    } else {
+      if (feeds.length === 0) {
+        console.log(chalk12.yellow("No registered feeds found"));
+        return;
+      }
+      console.log(chalk12.white(`Found ${feeds.length} registered feed(s):
+`));
+      feeds.forEach((feed, i) => {
+        console.log(formatFeed(feed, i));
+        if (i < feeds.length - 1) {
+          console.log();
+        }
+      });
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch feeds: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedListCommand(parent, commandName = "list") {
+  parent.command(commandName).description("List registered feeds").option(
+    "--limit <n>",
+    "Maximum number of feeds to display",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option("--json", "Output in JSON format").action(async (options) => {
+    await executeFeedList(options);
+  });
+}
+var MAX_HISTORY_ENTRIES = 100;
+var STATE_DIR = path.join(os.homedir(), ".botchan");
+var STATE_FILE = path.join(STATE_DIR, "state.json");
+function ensureStateDir() {
+  if (!fs.existsSync(STATE_DIR)) {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+  }
+}
+function loadState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      const data = fs.readFileSync(STATE_FILE, "utf-8");
+      return JSON.parse(data);
+    }
+  } catch {
+  }
+  return { feeds: {} };
+}
+function saveState(state) {
+  ensureStateDir();
+  const tempFile = `${STATE_FILE}.tmp`;
+  fs.writeFileSync(tempFile, JSON.stringify(state, null, 2));
+  fs.renameSync(tempFile, STATE_FILE);
+}
+function getLastSeenTimestamp(feedName) {
+  const state = loadState();
+  return state.feeds[feedName]?.lastSeenTimestamp ?? null;
+}
+function setLastSeenTimestamp(feedName, timestamp) {
+  const state = loadState();
+  if (!state.feeds[feedName]) {
+    state.feeds[feedName] = { lastSeenTimestamp: timestamp };
+  } else {
+    state.feeds[feedName].lastSeenTimestamp = timestamp;
+  }
+  saveState(state);
+}
+function markFeedSeen(feedName, posts) {
+  if (posts.length === 0) return;
+  const maxTimestamp = posts.reduce(
+    (max, post) => post.timestamp > max ? post.timestamp : max,
+    posts[0].timestamp
+  );
+  setLastSeenTimestamp(feedName, Number(maxTimestamp));
+}
+function getMyAddress() {
+  const state = loadState();
+  return state.myAddress ?? null;
+}
+function setMyAddress(address) {
+  const state = loadState();
+  state.myAddress = address.toLowerCase();
+  saveState(state);
+}
+function clearMyAddress() {
+  const state = loadState();
+  delete state.myAddress;
+  saveState(state);
+}
+function getFullState() {
+  return loadState();
+}
+function resetState() {
+  if (fs.existsSync(STATE_FILE)) {
+    fs.unlinkSync(STATE_FILE);
+  }
+}
+function getStateFilePath() {
+  return STATE_FILE;
+}
+function addHistoryEntry(entry) {
+  const state = loadState();
+  const history = state.history ?? [];
+  const newEntry = {
+    ...entry,
+    timestamp: Math.floor(Date.now() / 1e3)
+  };
+  history.unshift(newEntry);
+  if (history.length > MAX_HISTORY_ENTRIES) {
+    history.length = MAX_HISTORY_ENTRIES;
+  }
+  state.history = history;
+  saveState(state);
+}
+function getHistory(limit) {
+  const state = loadState();
+  const history = state.history ?? [];
+  return limit ? history.slice(0, limit) : history;
+}
+function getHistoryByType(type, limit) {
+  const history = getHistory();
+  const filtered = history.filter((entry) => entry.type === type);
+  return limit ? filtered.slice(0, limit) : filtered;
+}
+function clearHistory() {
+  const state = loadState();
+  state.history = [];
+  saveState(state);
+}
+function getHistoryCount() {
+  const state = loadState();
+  return state.history?.length ?? 0;
+}
+function isWalletAddress(feed) {
+  return /^0x[a-fA-F0-9]{40}$/.test(feed);
+}
+function getContacts() {
+  const history = getHistory();
+  const contactMap = /* @__PURE__ */ new Map();
+  for (const entry of history) {
+    if (entry.type === "post" && isWalletAddress(entry.feed)) {
+      const address = entry.feed.toLowerCase();
+      const existing = contactMap.get(address);
+      if (existing) {
+        existing.interactionCount++;
+        if (entry.timestamp > existing.lastInteraction) {
+          existing.lastInteraction = entry.timestamp;
+        }
+        if (entry.timestamp < existing.firstInteraction) {
+          existing.firstInteraction = entry.timestamp;
+        }
+      } else {
+        contactMap.set(address, {
+          address,
+          lastInteraction: entry.timestamp,
+          firstInteraction: entry.timestamp,
+          interactionCount: 1
+        });
+      }
+    }
+  }
+  return Array.from(contactMap.values()).sort(
+    (a, b) => b.lastInteraction - a.lastInteraction
+  );
+}
+function getActiveFeeds() {
+  const history = getHistory();
+  const feedMap = /* @__PURE__ */ new Map();
+  for (const entry of history) {
+    if (isWalletAddress(entry.feed)) continue;
+    if (entry.type === "register") continue;
+    const feedName = entry.feed.toLowerCase();
+    const existing = feedMap.get(feedName);
+    if (existing) {
+      if (entry.type === "post") existing.postCount++;
+      if (entry.type === "comment") existing.commentCount++;
+      if (entry.timestamp > existing.lastActivity) {
+        existing.lastActivity = entry.timestamp;
+      }
+      if (entry.timestamp < existing.firstActivity) {
+        existing.firstActivity = entry.timestamp;
+      }
+    } else {
+      feedMap.set(feedName, {
+        feed: feedName,
+        postCount: entry.type === "post" ? 1 : 0,
+        commentCount: entry.type === "comment" ? 1 : 0,
+        lastActivity: entry.timestamp,
+        firstActivity: entry.timestamp
+      });
+    }
+  }
+  return Array.from(feedMap.values()).sort(
+    (a, b) => b.lastActivity - a.lastActivity
+  );
+}
+
+// src/commands/feed/types.ts
+function normalizeFeedName(feed) {
+  return feed.toLowerCase();
+}
+
+// src/commands/feed/read.ts
+async function executeFeedRead(feed, options) {
+  const normalizedFeed = normalizeFeedName(feed);
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createFeedClient(readOnlyOptions);
+  const limit = options.limit ?? 20;
+  try {
+    const count = await client.getFeedPostCount(normalizedFeed);
+    if (count === 0) {
+      if (options.json) {
+        printJson([]);
+      } else {
+        console.log(chalk12.yellow(`No posts found in feed "${normalizedFeed}"`));
+      }
+      return;
+    }
+    const fetchLimit = options.sender ? Math.max(limit * 5, 100) : limit;
+    let posts = await client.getFeedPosts({
+      topic: normalizedFeed,
+      maxPosts: fetchLimit
+    });
+    if (options.sender) {
+      const senderLower = options.sender.toLowerCase();
+      posts = posts.filter(
+        (post) => post.sender.toLowerCase() === senderLower
+      );
+      posts = posts.slice(0, limit);
+    }
+    if (options.unseen) {
+      const lastSeen = getLastSeenTimestamp(normalizedFeed);
+      const myAddress = getMyAddress();
+      posts = posts.filter((post) => {
+        const isNew = lastSeen === null || Number(post.timestamp) > lastSeen;
+        const isFromOther = !myAddress || post.sender.toLowerCase() !== myAddress;
+        return isNew && isFromOther;
+      });
+    }
+    if (options.markSeen) {
+      const allPosts = await client.getFeedPosts({
+        topic: normalizedFeed,
+        maxPosts: 1
+        // Just need the latest
+      });
+      if (allPosts.length > 0) {
+        markFeedSeen(normalizedFeed, allPosts);
+      }
+    }
+    const commentCounts = await Promise.all(
+      posts.map((post) => client.getCommentCount(post))
+    );
+    if (options.json) {
+      printJson(
+        posts.map((post, i) => postToJson(post, i, commentCounts[i]))
+      );
+    } else {
+      if (posts.length === 0) {
+        const senderNote2 = options.sender ? ` by ${options.sender}` : "";
+        console.log(chalk12.yellow(`No posts found in feed "${normalizedFeed}"${senderNote2}`));
+        return;
+      }
+      const senderNote = options.sender ? ` by ${options.sender}` : "";
+      console.log(
+        chalk12.white(`Found ${posts.length} post(s) in feed "${normalizedFeed}"${senderNote}:
+`)
+      );
+      posts.forEach((post, i) => {
+        console.log(formatPost(post, i, { commentCount: commentCounts[i] }));
+        if (i < posts.length - 1) {
+          console.log();
+        }
+      });
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to read feed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedReadCommand(parent) {
+  parent.command("read <feed>").description("Read posts from a feed").option(
+    "--limit <n>",
+    "Maximum number of posts to display",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option("--sender <address>", "Filter posts by sender address").option("--unseen", "Only show posts not yet seen (newer than last --mark-seen)").option("--mark-seen", "Mark the feed as seen up to the latest post").option("--json", "Output in JSON format").action(async (feed, options) => {
+    await executeFeedRead(feed, options);
+  });
+}
+function createWallet(privateKey, chainId, rpcUrl) {
+  const account = privateKeyToAccount(privateKey);
+  const rpcUrls = getChainRpcUrls({
+    chainId,
+    rpcUrl
+  });
+  return createWalletClient({
+    account,
+    transport: http(rpcUrls[0])
+  });
+}
+async function executeTransaction(walletClient, txConfig) {
+  const hash = await walletClient.writeContract({
+    address: txConfig.to,
+    abi: txConfig.abi,
+    functionName: txConfig.functionName,
+    args: txConfig.args,
+    value: txConfig.value,
+    chain: null
+  });
+  return hash;
+}
+function encodeTransaction(config, chainId) {
+  const calldata = encodeFunctionData({
+    abi: config.abi,
+    functionName: config.functionName,
+    args: config.args
+  });
+  return {
+    to: config.to,
+    data: calldata,
+    chainId,
+    value: config.value?.toString() ?? "0"
+  };
+}
+
+// src/commands/feed/post.ts
+var MAX_MESSAGE_LENGTH = 4e3;
+async function executeFeedPost(feed, message, options) {
+  const normalizedFeed = normalizeFeedName(feed);
+  if (message.length === 0) {
+    exitWithError("Message cannot be empty");
+  }
+  const fullMessage = options.body ? `${message}
+
+${options.body}` : message;
+  if (fullMessage.length > MAX_MESSAGE_LENGTH) {
+    exitWithError(
+      `Message too long (${fullMessage.length} chars). Maximum is ${MAX_MESSAGE_LENGTH} characters.`
+    );
+  }
+  if (options.encodeOnly) {
+    const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const client2 = createFeedClient(readOnlyOptions);
+    const txConfig2 = client2.preparePostToFeed({
+      topic: normalizedFeed,
+      text: fullMessage,
+      data: options.data
+    });
+    const encoded = encodeTransaction(txConfig2, readOnlyOptions.chainId);
+    printJson(encoded);
+    return;
+  }
+  const commonOptions = parseCommonOptionsWithDefault(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+    // supports --encode-only
+  );
+  const client = createFeedClient(commonOptions);
+  const txConfig = client.preparePostToFeed({
+    topic: normalizedFeed,
+    text: fullMessage,
+    data: options.data
+  });
+  const walletClient = createWallet(
+    commonOptions.privateKey,
+    commonOptions.chainId,
+    commonOptions.rpcUrl
+  );
+  console.log(chalk12.blue(`Posting to feed "${normalizedFeed}"...`));
+  try {
+    const hash = await executeTransaction(walletClient, txConfig);
+    const senderAddress = walletClient.account.address;
+    let postId;
+    try {
+      const posts = await client.getFeedPosts({
+        topic: normalizedFeed,
+        maxPosts: 10
+      });
+      const ourPost = posts.find(
+        (p) => p.sender.toLowerCase() === senderAddress.toLowerCase() && p.text === fullMessage
+      );
+      if (ourPost) {
+        postId = `${ourPost.sender}:${ourPost.timestamp}`;
+      }
+    } catch {
+    }
+    addHistoryEntry({
+      type: "post",
+      txHash: hash,
+      chainId: commonOptions.chainId,
+      feed: normalizedFeed,
+      sender: senderAddress,
+      text: fullMessage,
+      postId
+      // Now we have the actual post ID for checking comments later
+    });
+    const displayText = options.body ? `${message} (+ body)` : message;
+    const postIdInfo = postId ? `
+  Post ID: ${postId}` : "";
+    console.log(
+      chalk12.green(
+        `Message posted successfully!
+  Transaction: ${hash}
+  Feed: ${normalizedFeed}${postIdInfo}
+  Text: ${displayText}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to post message: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedPostCommand(parent) {
+  parent.command("post <feed> <message>").description("Post a message to a feed").option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).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) => {
+    await executeFeedPost(feed, message, options);
+  });
+}
+
+// src/shared/postId.ts
+function parsePostId(postId) {
+  const parts = postId.split(":");
+  if (parts.length !== 2) {
+    throw new Error(
+      `Invalid post ID format. Expected {sender}:{timestamp}, got: ${postId}`
+    );
+  }
+  const [sender, timestampStr] = parts;
+  if (!sender.startsWith("0x") || sender.length !== 42) {
+    throw new Error(`Invalid sender address in post ID: ${sender}`);
+  }
+  const timestamp = BigInt(timestampStr);
+  if (timestamp <= 0) {
+    throw new Error(`Invalid timestamp in post ID: ${timestampStr}`);
+  }
+  return {
+    sender,
+    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;
+async function executeFeedCommentWrite(feed, postId, message, options) {
+  const normalizedFeed = normalizeFeedName(feed);
+  if (message.length === 0) {
+    exitWithError("Comment cannot be empty");
+  }
+  if (message.length > MAX_MESSAGE_LENGTH2) {
+    exitWithError(
+      `Comment too long (${message.length} chars). Maximum is ${MAX_MESSAGE_LENGTH2} characters.`
+    );
+  }
+  let parsedId;
+  try {
+    parsedId = parsePostId(postId);
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : "Invalid post ID format"
+    );
+  }
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createFeedClient(readOnlyOptions);
+  const count = await client.getFeedPostCount(normalizedFeed);
+  if (count === 0) {
+    exitWithError(
+      `Feed "${normalizedFeed}" has no posts. Cannot find post ${postId}.`
+    );
+  }
+  const posts = await client.getFeedPosts({
+    topic: normalizedFeed,
+    maxPosts: 100
+    // Fetch enough to find the post
+  });
+  const targetPost = findPostByParsedId(posts, parsedId);
+  if (!targetPost) {
+    exitWithError(
+      `Post not found with ID ${postId} in feed "${normalizedFeed}". Make sure the sender and timestamp are correct.`
+    );
+  }
+  const txConfig = client.prepareComment({
+    post: targetPost,
+    text: message
+  });
+  if (options.encodeOnly) {
+    const encoded = encodeTransaction(txConfig, readOnlyOptions.chainId);
+    printJson(encoded);
+    return;
+  }
+  const commonOptions = parseCommonOptionsWithDefault(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+    // supports --encode-only
+  );
+  const walletClient = createWallet(
+    commonOptions.privateKey,
+    commonOptions.chainId,
+    commonOptions.rpcUrl
+  );
+  console.log(chalk12.blue(`Commenting on post ${postId}...`));
+  try {
+    const hash = await executeTransaction(walletClient, txConfig);
+    addHistoryEntry({
+      type: "comment",
+      txHash: hash,
+      chainId: commonOptions.chainId,
+      feed: normalizedFeed,
+      sender: walletClient.account.address,
+      text: message,
+      postId
+    });
+    console.log(
+      chalk12.green(
+        `Comment posted successfully!
+  Transaction: ${hash}
+  Post: ${postId}
+  Comment: ${message}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to post comment: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedCommentWriteCommand(parent) {
+  parent.command("comment <feed> <post-id> <message>").description(
+    "Comment on a post. Post ID format: {sender}:{timestamp}"
+  ).option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).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"
+  ).action(async (feed, postId, message, options) => {
+    await executeFeedCommentWrite(feed, postId, message, options);
+  });
+}
+async function executeFeedCommentRead(feed, postId, options) {
+  const normalizedFeed = normalizeFeedName(feed);
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createFeedClient(readOnlyOptions);
+  let parsedId;
+  try {
+    parsedId = parsePostId(postId);
+  } catch (error) {
+    exitWithError(
+      error instanceof Error ? error.message : "Invalid post ID format"
+    );
+  }
+  try {
+    const count = await client.getFeedPostCount(normalizedFeed);
+    if (count === 0) {
+      exitWithError(
+        `Feed "${normalizedFeed}" has no posts. Cannot find post ${postId}.`
+      );
+    }
+    const posts = await client.getFeedPosts({
+      topic: normalizedFeed,
+      maxPosts: 100
+      // Fetch enough to find the post
+    });
+    const targetPost = findPostByParsedId(posts, parsedId);
+    if (!targetPost) {
+      exitWithError(
+        `Post not found with ID ${postId} in feed "${normalizedFeed}". Make sure the sender and timestamp are correct.`
+      );
+    }
+    const commentCount = await client.getCommentCount(targetPost);
+    if (commentCount === 0) {
+      if (options.json) {
+        printJson([]);
+      } else {
+        console.log(chalk12.yellow(`No comments found for post ${postId}`));
+      }
+      return;
+    }
+    const comments = await client.getComments({
+      post: targetPost,
+      maxComments: options.limit ?? 50
+    });
+    const commentsWithDepth = comments.map((comment) => ({
+      comment,
+      depth: 0
+    }));
+    if (options.json) {
+      printJson(
+        commentsWithDepth.map(
+          ({ comment, depth }) => commentToJson(comment, depth)
+        )
+      );
+    } else {
+      if (comments.length === 0) {
+        console.log(chalk12.yellow(`No comments found for post ${postId}`));
+        return;
+      }
+      console.log(
+        chalk12.white(`Found ${comments.length} comment(s) for post ${postId}:
+`)
+      );
+      commentsWithDepth.forEach(({ comment, depth }, i) => {
+        console.log(formatComment(comment, depth));
+        if (i < commentsWithDepth.length - 1) {
+          console.log();
+        }
+      });
+    }
+  } catch (error) {
+    if (error.message?.includes("Post not found")) {
+      throw error;
+    }
+    exitWithError(
+      `Failed to fetch comments: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedCommentReadCommand(parent) {
+  parent.command("comments <feed> <post-id>").description(
+    "Read comments on a post. Post ID format: {sender}:{timestamp}"
+  ).option(
+    "--limit <n>",
+    "Maximum number of comments to display",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option("--json", "Output in JSON format").action(async (feed, postId, options) => {
+    await executeFeedCommentRead(feed, postId, options);
+  });
+}
+async function executeFeedRegister(feedName, options) {
+  if (feedName.length > 64) {
+    exitWithError("Feed name cannot exceed 64 characters");
+  }
+  if (feedName.length === 0) {
+    exitWithError("Feed name cannot be empty");
+  }
+  if (options.encodeOnly) {
+    const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    });
+    const client2 = createFeedRegistryClient(readOnlyOptions);
+    const txConfig2 = client2.prepareRegisterFeed({ feedName });
+    const encoded = encodeTransaction(txConfig2, readOnlyOptions.chainId);
+    printJson(encoded);
+    return;
+  }
+  const commonOptions = parseCommonOptionsWithDefault(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+    // supports --encode-only
+  );
+  const client = createFeedRegistryClient(commonOptions);
+  const isRegistered = await client.isFeedRegistered(feedName);
+  if (isRegistered) {
+    exitWithError(`Feed "${feedName}" is already registered`);
+  }
+  const txConfig = client.prepareRegisterFeed({ feedName });
+  const walletClient = createWallet(
+    commonOptions.privateKey,
+    commonOptions.chainId,
+    commonOptions.rpcUrl
+  );
+  console.log(chalk12.blue(`Registering feed "${feedName}"...`));
+  try {
+    const hash = await executeTransaction(walletClient, txConfig);
+    addHistoryEntry({
+      type: "register",
+      txHash: hash,
+      chainId: commonOptions.chainId,
+      feed: feedName,
+      sender: walletClient.account.address
+    });
+    console.log(
+      chalk12.green(
+        `Feed registered successfully!
+  Transaction: ${hash}
+  Feed: ${feedName}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to register feed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedRegisterCommand(parent) {
+  parent.command("register <feed-name>").description("Register a new feed").option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).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"
+  ).action(async (feedName, options) => {
+    await executeFeedRegister(feedName, options);
+  });
+}
+function truncateText(text, maxLen) {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen) + "...";
+}
+async function executeFeedReplies(options) {
+  const postHistory = getHistoryByType("post", options.limit ?? 10);
+  const postsWithIds = postHistory.filter(
+    (entry) => !!entry.postId
+  );
+  if (postsWithIds.length === 0) {
+    if (options.json) {
+      printJson([]);
+    } else {
+      console.log(chalk12.gray("No posts with trackable IDs found in history."));
+      console.log(
+        chalk12.gray("Post IDs are captured when you post with a wallet.")
+      );
+    }
+    return;
+  }
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createFeedClient(readOnlyOptions);
+  console.log(chalk12.blue(`Checking replies on ${postsWithIds.length} posts...
+`));
+  const results = [];
+  for (const entry of postsWithIds) {
+    try {
+      const [sender, timestampStr] = entry.postId.split(":");
+      const timestamp = BigInt(timestampStr);
+      const postObj = {
+        sender,
+        timestamp,
+        text: entry.text ?? "",
+        topic: entry.feed,
+        app: "",
+        data: "0x"
+      };
+      const commentCount = await client.getCommentCount(postObj);
+      results.push({
+        feed: entry.feed,
+        postId: entry.postId,
+        text: entry.text ?? "",
+        postedAt: entry.timestamp,
+        commentCount: Number(commentCount)
+      });
+    } catch {
+    }
+  }
+  if (options.json) {
+    printJson(results);
+    return;
+  }
+  const postsWithReplies = results.filter((r) => r.commentCount > 0);
+  const totalReplies = results.reduce((sum, r) => sum + r.commentCount, 0);
+  console.log(
+    chalk12.cyan(
+      `Found ${totalReplies} total replies across ${postsWithReplies.length} posts
+`
+    )
+  );
+  if (results.length === 0) {
+    console.log(chalk12.gray("Could not check any posts."));
+    return;
+  }
+  results.sort((a, b) => b.commentCount - a.commentCount);
+  for (const post of results) {
+    const timeAgo = formatTimestamp(post.postedAt);
+    const replyText = post.commentCount === 0 ? chalk12.gray("no replies") : post.commentCount === 1 ? chalk12.green("1 reply") : chalk12.green(`${post.commentCount} replies`);
+    console.log(
+      `${chalk12.white(post.feed)} ${chalk12.gray("\u2022")} ${replyText} ${chalk12.gray(`\u2022 ${timeAgo}`)}`
+    );
+    console.log(`  ${chalk12.gray(truncateText(post.text, 60))}`);
+    if (post.commentCount > 0) {
+      console.log(
+        chalk12.blue(`  \u2192 netp feed comments ${post.feed} ${post.postId}`)
+      );
+    }
+    console.log("");
+  }
+}
+function registerFeedRepliesCommand(parent) {
+  parent.command("replies").description("Check for replies on your recent posts").option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option(
+    "--limit <n>",
+    "Number of recent posts to check (default: 10)",
+    (value) => parseInt(value, 10)
+  ).option("--json", "Output as JSON").action(async (options) => {
+    await executeFeedReplies(options);
+  });
+}
+async function executeFeedPosts(address, options) {
+  if (!address.startsWith("0x") || address.length !== 42) {
+    exitWithError("Invalid address format. Must be 0x-prefixed, 42 characters");
+  }
+  const readOnlyOptions = parseReadOnlyOptionsWithDefault({
+    chainId: options.chainId,
+    rpcUrl: options.rpcUrl
+  });
+  const client = createNetClient(readOnlyOptions);
+  const limit = options.limit ?? 20;
+  try {
+    const count = await client.getMessageCount({
+      filter: {
+        appAddress: NULL_ADDRESS,
+        maker: address
+      }
+    });
+    if (count === 0) {
+      if (options.json) {
+        printJson([]);
+      } else {
+        console.log(chalk12.yellow(`No posts found for address ${address}`));
+      }
+      return;
+    }
+    const startIndex = count > limit ? count - limit : 0;
+    const messages = await client.getMessages({
+      filter: {
+        appAddress: NULL_ADDRESS,
+        maker: address
+      },
+      startIndex,
+      endIndex: count
+    });
+    if (options.json) {
+      printJson(messages.map((msg, i) => postToJson(msg, i)));
+    } else {
+      console.log(
+        chalk12.white(`Found ${messages.length} post(s) by ${address}:
+`)
+      );
+      messages.forEach((msg, i) => {
+        console.log(formatPost(msg, i, { showTopic: true }));
+        if (i < messages.length - 1) {
+          console.log();
+        }
+      });
+    }
+  } catch (error) {
+    exitWithError(
+      `Failed to fetch posts: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerFeedPostsCommand(parent) {
+  parent.command("posts <address>").description("View posts by an address").option(
+    "--limit <n>",
+    "Maximum number of posts to display",
+    (value) => parseInt(value, 10)
+  ).option(
+    "--chain-id <id>",
+    "Chain ID (default: 8453 for Base)",
+    (value) => parseInt(value, 10)
+  ).option("--rpc-url <url>", "Custom RPC URL").option("--json", "Output in JSON format").action(async (address, options) => {
+    await executeFeedPosts(address, options);
+  });
+}
+async function confirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(`${message} (y/N): `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+
+// src/commands/feed/config.ts
+async function executeFeedConfig(options) {
+  if (options.reset) {
+    const statePath = getStateFilePath();
+    console.log(chalk12.yellow(`This will delete all stored state at:`));
+    console.log(chalk12.white(`  ${statePath}`));
+    console.log(chalk12.yellow(`
+This includes:`));
+    console.log(chalk12.white(`  - All "last seen" timestamps for feeds`));
+    console.log(chalk12.white(`  - Your configured address`));
+    console.log(chalk12.white(`  - Your activity history`));
+    if (!options.force) {
+      const confirmed = await confirm(chalk12.red("\nAre you sure you want to reset?"));
+      if (!confirmed) {
+        console.log(chalk12.gray("Cancelled."));
+        return;
+      }
+    }
+    resetState();
+    console.log(chalk12.green("State reset successfully."));
+    return;
+  }
+  if (options.myAddress) {
+    if (!options.myAddress.match(/^0x[a-fA-F0-9]{40}$/)) {
+      console.error(chalk12.red("Invalid address format. Expected 0x followed by 40 hex characters."));
+      process.exit(1);
+    }
+    setMyAddress(options.myAddress);
+    console.log(chalk12.green(`Set my address to: ${options.myAddress}`));
+    return;
+  }
+  if (options.clearAddress) {
+    clearMyAddress();
+    console.log(chalk12.green("Cleared my address."));
+    return;
+  }
+  const state = getFullState();
+  const myAddress = getMyAddress();
+  console.log(chalk12.cyan("Feed Configuration\n"));
+  console.log(chalk12.white(`State file: ${getStateFilePath()}`));
+  console.log(chalk12.white(`My address: ${myAddress ?? chalk12.gray("(not set)")}`));
+  const feedCount = Object.keys(state.feeds).length;
+  console.log(chalk12.white(`Tracked feeds: ${feedCount}`));
+  const historyCount = getHistoryCount();
+  console.log(chalk12.white(`History entries: ${historyCount}`));
+  if (feedCount > 0 && feedCount <= 20) {
+    console.log(chalk12.gray("\nLast seen timestamps:"));
+    for (const [feed, data] of Object.entries(state.feeds)) {
+      const date = new Date(data.lastSeenTimestamp * 1e3);
+      console.log(chalk12.gray(`  ${feed}: ${date.toLocaleString()}`));
+    }
+  } else if (feedCount > 20) {
+    console.log(chalk12.gray(`
+(${feedCount} feeds tracked, use --json for full list)`));
+  }
+  const activeFeeds = getActiveFeeds();
+  if (activeFeeds.length > 0) {
+    console.log(chalk12.cyan("\nActive Feeds:"));
+    const displayFeeds = activeFeeds.slice(0, 10);
+    for (const feed of displayFeeds) {
+      const activity = [];
+      if (feed.postCount > 0) activity.push(`${feed.postCount} post${feed.postCount !== 1 ? "s" : ""}`);
+      if (feed.commentCount > 0) activity.push(`${feed.commentCount} comment${feed.commentCount !== 1 ? "s" : ""}`);
+      const lastActive = formatTimestamp(feed.lastActivity);
+      console.log(chalk12.white(`  ${feed.feed}`) + chalk12.gray(` \u2022 ${activity.join(", ")} \u2022 ${lastActive}`));
+    }
+    if (activeFeeds.length > 10) {
+      console.log(chalk12.gray(`  ... and ${activeFeeds.length - 10} more`));
+    }
+  }
+  const contacts = getContacts();
+  if (contacts.length > 0) {
+    console.log(chalk12.cyan("\nRecent Contacts (DMs):"));
+    const displayContacts = contacts.slice(0, 10);
+    for (const contact of displayContacts) {
+      const truncAddr = `${contact.address.slice(0, 6)}...${contact.address.slice(-4)}`;
+      const msgCount = contact.interactionCount;
+      const lastActive = formatTimestamp(contact.lastInteraction);
+      console.log(
+        chalk12.white(`  ${truncAddr}`) + chalk12.gray(` \u2022 ${msgCount} message${msgCount !== 1 ? "s" : ""} \u2022 ${lastActive}`)
+      );
+    }
+    if (contacts.length > 10) {
+      console.log(chalk12.gray(`  ... and ${contacts.length - 10} more`));
+    }
+  }
+}
+function registerFeedConfigCommand(parent) {
+  parent.command("config").description("View or modify feed configuration").option("--my-address <address>", "Set your address (to filter out own posts with --unseen)").option("--clear-address", "Clear your configured address").option("--show", "Show current configuration (default)").option("--reset", "Reset all state (clears last-seen timestamps and address)").option("--force", "Skip confirmation prompt for --reset").action(async (options) => {
+    await executeFeedConfig(options);
+  });
+}
+function formatHistoryEntry(entry, index) {
+  const timestamp = formatTimestamp(entry.timestamp);
+  const typeColor = entry.type === "post" ? chalk12.green : entry.type === "comment" ? chalk12.blue : chalk12.yellow;
+  const lines = [
+    chalk12.cyan(`[${index}]`) + ` ${chalk12.gray(timestamp)} ` + typeColor(entry.type.toUpperCase()),
+    `  ${chalk12.white("Feed:")} ${entry.feed}`,
+    `  ${chalk12.white("Tx:")} ${entry.txHash}`
+  ];
+  if (entry.sender) {
+    lines.push(`  ${chalk12.white("Sender:")} ${truncateAddress(entry.sender)}`);
+  }
+  if (entry.text) {
+    const truncatedText = entry.text.length > 80 ? entry.text.slice(0, 80) + "..." : entry.text;
+    lines.push(`  ${chalk12.white("Text:")} ${truncatedText}`);
+  }
+  if (entry.type === "post" && entry.postId) {
+    lines.push(`  ${chalk12.white("Post ID:")} ${entry.postId}`);
+  } else if (entry.type === "comment" && entry.postId) {
+    lines.push(`  ${chalk12.white("Reply to:")} ${entry.postId}`);
+  }
+  if (entry.type === "post" && entry.postId) {
+    lines.push(
+      chalk12.gray(`  \u2192 Check replies: netp feed comments ${entry.feed} ${entry.postId}`)
+    );
+  } else if (entry.type === "post" && entry.sender) {
+    lines.push(
+      chalk12.gray(`  \u2192 Find post: netp feed read ${entry.feed} --sender ${entry.sender} --json`)
+    );
+  } else if (entry.type === "comment" && entry.postId) {
+    lines.push(
+      chalk12.gray(`  \u2192 See thread: netp feed comments ${entry.feed} ${entry.postId}`)
+    );
+  }
+  return lines.join("\n");
+}
+function historyEntryToJson(entry, index) {
+  const result = {
+    index,
+    type: entry.type,
+    timestamp: entry.timestamp,
+    txHash: entry.txHash,
+    chainId: entry.chainId,
+    feed: entry.feed
+  };
+  if (entry.sender) {
+    result.sender = entry.sender;
+  }
+  if (entry.text) {
+    result.text = entry.text;
+  }
+  if (entry.postId) {
+    result.postId = entry.postId;
+  }
+  return result;
+}
+function validateType(type) {
+  const validTypes = ["post", "comment", "register"];
+  if (!validTypes.includes(type)) {
+    console.error(
+      chalk12.red(
+        `Invalid type "${type}". Must be one of: ${validTypes.join(", ")}`
+      )
+    );
+    process.exit(1);
+  }
+  return type;
+}
+async function executeFeedHistory(options) {
+  if (options.clear) {
+    const count = getHistoryCount();
+    if (count === 0) {
+      console.log(chalk12.gray("History is already empty."));
+      return;
+    }
+    console.log(chalk12.yellow(`This will delete ${count} history entries.`));
+    if (!options.force) {
+      const confirmed = await confirm(
+        chalk12.red("\nAre you sure you want to clear history?")
+      );
+      if (!confirmed) {
+        console.log(chalk12.gray("Cancelled."));
+        return;
+      }
+    }
+    clearHistory();
+    console.log(chalk12.green("History cleared."));
+    return;
+  }
+  let entries;
+  if (options.type) {
+    const validType = validateType(options.type);
+    entries = getHistoryByType(validType, options.limit);
+  } else {
+    entries = getHistory(options.limit);
+  }
+  if (entries.length === 0) {
+    if (options.json) {
+      printJson([]);
+    } else {
+      console.log(chalk12.gray("No history entries found."));
+      console.log(
+        chalk12.gray(
+          "History is recorded when you post, comment, or register feeds."
+        )
+      );
+    }
+    return;
+  }
+  if (options.json) {
+    const jsonEntries = entries.map(
+      (entry, idx) => historyEntryToJson(entry, idx)
+    );
+    printJson(jsonEntries);
+  } else {
+    const totalCount = getHistoryCount();
+    const typeFilter = options.type ? ` (type: ${options.type})` : "";
+    console.log(
+      chalk12.cyan(`Feed History${typeFilter} (${entries.length} of ${totalCount})
+`)
+    );
+    for (let i = 0; i < entries.length; i++) {
+      console.log(formatHistoryEntry(entries[i], i));
+      if (i < entries.length - 1) {
+        console.log("");
+      }
+    }
+  }
+}
+function registerFeedHistoryCommand(parent) {
+  parent.command("history").description("View feed activity history (posts, comments, registrations)").option(
+    "--limit <n>",
+    "Limit number of entries",
+    (value) => parseInt(value, 10)
+  ).option("--type <type>", "Filter by type: post, comment, or register").option("--json", "Output as JSON").option("--clear", "Clear all history").option("--force", "Skip confirmation prompt for --clear").action(async (options) => {
+    await executeFeedHistory(options);
+  });
+}
+
+// src/commands/feed/index.ts
+function registerFeedCommand(program) {
+  const feedCommand = program.command("feed").description("Feed operations (read/write posts, comments, manage feeds)");
+  registerFeedListCommand(feedCommand);
+  registerFeedReadCommand(feedCommand);
+  registerFeedPostCommand(feedCommand);
+  registerFeedCommentWriteCommand(feedCommand);
+  registerFeedCommentReadCommand(feedCommand);
+  registerFeedRegisterCommand(feedCommand);
+  registerFeedRepliesCommand(feedCommand);
+  registerFeedPostsCommand(feedCommand);
+  registerFeedConfigCommand(feedCommand);
+  registerFeedHistoryCommand(feedCommand);
+}
+
+export { registerFeedCommand, registerFeedCommentReadCommand, registerFeedCommentWriteCommand, registerFeedConfigCommand, registerFeedHistoryCommand, registerFeedListCommand, registerFeedPostCommand, registerFeedPostsCommand, registerFeedReadCommand, registerFeedRegisterCommand, registerFeedRepliesCommand };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map