botchan 0.1.0

package/dist/cli/index.mjs

@@ -0,0 +1,2728 @@
+#!/usr/bin/env node
+import chalk10 from 'chalk';
+import { encodeFunctionData, createWalletClient, http } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { NULL_ADDRESS, NetClient, getChainRpcUrls } from '@net-protocol/core';
+import { FeedRegistryClient, FeedClient, generatePostHash, parseCommentData } from '@net-protocol/feeds';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import React5, { useState, useCallback, useEffect, useRef } from 'react';
+import { render, useStdout, Box, useInput, Text } from 'ink';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import * as readline from 'readline';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+function normalizeFeedName(feed) {
+  return feed.toLowerCase();
+}
+function getChainId(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 getRpcUrl(optionValue) {
+  return optionValue || process.env.BOTCHAN_RPC_URL || process.env.NET_RPC_URL;
+}
+function parseReadOnlyOptions(options) {
+  return {
+    chainId: getChainId(options.chainId),
+    rpcUrl: getRpcUrl(options.rpcUrl)
+  };
+}
+function parseCommonOptions(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(
+      chalk10.red(
+        `Error: Private key is required. Provide via --private-key flag or BOTCHAN_PRIVATE_KEY/NET_PRIVATE_KEY environment variable${encodeOnlyHint}`
+      )
+    );
+    process.exit(1);
+  }
+  if (!privateKey.startsWith("0x") || privateKey.length !== 66) {
+    console.error(
+      chalk10.red(
+        "Error: Invalid private key format (must be 0x-prefixed, 66 characters)"
+      )
+    );
+    process.exit(1);
+  }
+  if (options.privateKey) {
+    console.warn(
+      chalk10.yellow(
+        "Warning: Private key provided via command line. Consider using BOTCHAN_PRIVATE_KEY environment variable instead."
+      )
+    );
+  }
+  return {
+    privateKey,
+    chainId: getChainId(options.chainId),
+    rpcUrl: getRpcUrl(options.rpcUrl)
+  };
+}
+var DEFAULT_CHAIN_ID;
+var init_config = __esm({
+  "src/utils/config.ts"() {
+    DEFAULT_CHAIN_ID = 8453;
+  }
+});
+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;
+}
+var init_wallet = __esm({
+  "src/utils/wallet.ts"() {
+  }
+});
+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 = [
+    chalk10.cyan(`[${index}]`) + ` ${chalk10.gray(timestamp)}`,
+    `  ${chalk10.white("Sender:")} ${post.sender}`,
+    `  ${chalk10.white("Text:")} ${post.text}`
+  ];
+  if (showTopic && post.topic) {
+    const { feedName, isComment } = parseTopic(post.topic);
+    const prefix = isComment ? "Comment on" : "Feed";
+    lines.push(`  ${chalk10.white(prefix + ":")} ${chalk10.magenta(feedName)}`);
+  }
+  if (commentCount !== void 0) {
+    lines.push(`  ${chalk10.white("Comments:")} ${commentCount}`);
+  }
+  if (post.data && post.data !== "0x") {
+    lines.push(`  ${chalk10.white("Data:")} ${post.data}`);
+  }
+  return lines.join("\n");
+}
+function formatFeed(feed, index) {
+  const timestamp = formatTimestamp(feed.timestamp);
+  const lines = [
+    chalk10.cyan(`[${index}]`) + ` ${chalk10.white(feed.feedName)}`,
+    `    ${chalk10.gray("Registrant:")} ${feed.registrant}`,
+    `    ${chalk10.gray("Registered:")} ${timestamp}`
+  ];
+  return lines.join("\n");
+}
+function formatComment(comment, depth) {
+  const indent = "  ".repeat(depth + 1);
+  const timestamp = formatTimestamp(comment.timestamp);
+  const lines = [
+    `${indent}${chalk10.gray(timestamp)} ${chalk10.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));
+}
+function exitWithError(message) {
+  console.error(chalk10.red(`Error: ${message}`));
+  process.exit(1);
+}
+var init_output = __esm({
+  "src/utils/output.ts"() {
+  }
+});
+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"
+  };
+}
+var init_encode = __esm({
+  "src/utils/encode.ts"() {
+  }
+});
+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
+  });
+}
+var init_client = __esm({
+  "src/utils/client.ts"() {
+  }
+});
+
+// src/utils/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
+  );
+}
+var init_postId = __esm({
+  "src/utils/postId.ts"() {
+  }
+});
+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;
+}
+var STATE_DIR, STATE_FILE;
+var init_state = __esm({
+  "src/utils/state.ts"() {
+    STATE_DIR = path.join(os.homedir(), ".botchan");
+    STATE_FILE = path.join(STATE_DIR, "state.json");
+  }
+});
+
+// src/utils/index.ts
+var init_utils = __esm({
+  "src/utils/index.ts"() {
+    init_config();
+    init_wallet();
+    init_output();
+    init_encode();
+    init_client();
+    init_postId();
+    init_state();
+  }
+});
+function useFeeds(options) {
+  const [feeds, setFeeds] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const fetchFeeds = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const client = new FeedRegistryClient({
+        chainId: options.chainId,
+        overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+      });
+      const result = await client.getRegisteredFeeds({ maxFeeds: 100 });
+      setFeeds(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [options.chainId, options.rpcUrl]);
+  useEffect(() => {
+    fetchFeeds();
+  }, [fetchFeeds]);
+  return { feeds, loading, error, refetch: fetchFeeds };
+}
+function usePosts(feedName, options) {
+  const [posts, setPosts] = useState([]);
+  const [commentCounts, setCommentCounts] = useState(
+    /* @__PURE__ */ new Map()
+  );
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fetchPosts = useCallback(async () => {
+    if (!feedName) {
+      setPosts([]);
+      setCommentCounts(/* @__PURE__ */ new Map());
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const client = new FeedClient({
+        chainId: options.chainId,
+        overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+      });
+      const postCount = await client.getFeedPostCount(feedName);
+      if (postCount === 0) {
+        setPosts([]);
+        setCommentCounts(/* @__PURE__ */ new Map());
+        setLoading(false);
+        return;
+      }
+      const fetchLimit = options.senderFilter ? 200 : 50;
+      let result = await client.getFeedPosts({ topic: feedName, maxPosts: fetchLimit });
+      if (options.senderFilter) {
+        const senderLower = options.senderFilter.toLowerCase();
+        result = result.filter(
+          (post) => post.sender.toLowerCase() === senderLower
+        );
+      }
+      setPosts(result);
+      if (result.length > 0) {
+        const batchCounts = await client.getCommentCountBatch(result);
+        const counts = /* @__PURE__ */ new Map();
+        for (const post of result) {
+          const postHash = generatePostHash(post);
+          const key = `${post.sender}:${post.timestamp}`;
+          counts.set(key, batchCounts.get(postHash) ?? 0);
+        }
+        setCommentCounts(counts);
+      } else {
+        setCommentCounts(/* @__PURE__ */ new Map());
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [feedName, options.chainId, options.rpcUrl, options.senderFilter]);
+  useEffect(() => {
+    fetchPosts();
+  }, [fetchPosts]);
+  return { posts, commentCounts, loading, error, refetch: fetchPosts };
+}
+function buildCommentTree(rawComments) {
+  const commentMap = /* @__PURE__ */ new Map();
+  const childrenMap = /* @__PURE__ */ new Map();
+  for (const comment of rawComments) {
+    const key = `${comment.sender}:${comment.timestamp}`;
+    let replyToKey = null;
+    try {
+      const commentData = parseCommentData(comment.data);
+      if (commentData?.replyTo) {
+        replyToKey = `${commentData.replyTo.sender}:${commentData.replyTo.timestamp}`;
+      }
+    } catch {
+    }
+    commentMap.set(key, { comment, replyToKey });
+    const parentKey = replyToKey ?? "__root__";
+    if (!childrenMap.has(parentKey)) {
+      childrenMap.set(parentKey, []);
+    }
+    childrenMap.get(parentKey).push(key);
+  }
+  const result = [];
+  function traverse(parentKey, depth) {
+    const children = childrenMap.get(parentKey) ?? [];
+    for (const childKey of children) {
+      const item = commentMap.get(childKey);
+      if (item) {
+        result.push({
+          comment: item.comment,
+          depth,
+          replyToKey: item.replyToKey
+        });
+        traverse(childKey, depth + 1);
+      }
+    }
+  }
+  traverse("__root__", 0);
+  const addedKeys = new Set(result.map((r) => `${r.comment.sender}:${r.comment.timestamp}`));
+  for (const [key, item] of commentMap) {
+    if (!addedKeys.has(key)) {
+      result.push({
+        comment: item.comment,
+        depth: 0,
+        // Show as top-level since parent is missing
+        replyToKey: item.replyToKey
+      });
+    }
+  }
+  return result;
+}
+function useComments(post, options) {
+  const [comments, setComments] = useState([]);
+  const [replyCounts, setReplyCounts] = useState(
+    /* @__PURE__ */ new Map()
+  );
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const loadedPostRef = useRef(null);
+  const currentPostKey = post ? `${post.sender}:${post.timestamp}` : null;
+  const isLoading = loading || currentPostKey !== null && currentPostKey !== loadedPostRef.current;
+  useEffect(() => {
+    if (post) {
+      setLoading(true);
+      setComments([]);
+      setReplyCounts(/* @__PURE__ */ new Map());
+    }
+  }, [post]);
+  const fetchComments = useCallback(async () => {
+    if (!post) {
+      setComments([]);
+      setReplyCounts(/* @__PURE__ */ new Map());
+      setLoading(false);
+      loadedPostRef.current = null;
+      return;
+    }
+    const postKey = `${post.sender}:${post.timestamp}`;
+    setLoading(true);
+    setError(null);
+    try {
+      const client = new FeedClient({
+        chainId: options.chainId,
+        overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+      });
+      const commentCount = await client.getCommentCount(post);
+      if (commentCount === 0) {
+        setComments([]);
+        setReplyCounts(/* @__PURE__ */ new Map());
+        loadedPostRef.current = postKey;
+        setLoading(false);
+        return;
+      }
+      const result = await client.getComments({ post, maxComments: 200 });
+      const treeComments = buildCommentTree(result);
+      setComments(treeComments);
+      if (result.length > 0) {
+        const batchCounts = await client.getCommentCountBatch(result);
+        const counts = /* @__PURE__ */ new Map();
+        for (const comment of result) {
+          const commentHash = generatePostHash(comment);
+          const key = `${comment.sender}:${comment.timestamp}`;
+          counts.set(key, batchCounts.get(commentHash) ?? 0);
+        }
+        setReplyCounts(counts);
+      } else {
+        setReplyCounts(/* @__PURE__ */ new Map());
+      }
+      loadedPostRef.current = postKey;
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [post, options.chainId, options.rpcUrl]);
+  useEffect(() => {
+    fetchComments();
+  }, [fetchComments]);
+  return { comments, replyCounts, loading: isLoading, error, refetch: fetchComments };
+}
+function useProfile(address, options) {
+  const [messages, setMessages] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const loadedAddressRef = useRef(null);
+  const isLoading = loading || address !== null && address !== loadedAddressRef.current;
+  useEffect(() => {
+    if (address) {
+      setLoading(true);
+      setMessages([]);
+    }
+  }, [address]);
+  const fetchProfile = useCallback(async () => {
+    if (!address) {
+      setMessages([]);
+      setLoading(false);
+      loadedAddressRef.current = null;
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const client = new NetClient({
+        chainId: options.chainId,
+        overrides: options.rpcUrl ? { rpcUrls: [options.rpcUrl] } : void 0
+      });
+      const count = await client.getMessageCount({
+        filter: {
+          appAddress: NULL_ADDRESS,
+          maker: address
+        }
+      });
+      if (count === 0) {
+        setMessages([]);
+        loadedAddressRef.current = address;
+        setLoading(false);
+        return;
+      }
+      const limit = 50;
+      const startIndex = count > limit ? count - limit : 0;
+      const rawMessages = await client.getMessages({
+        filter: {
+          appAddress: NULL_ADDRESS,
+          maker: address
+        },
+        startIndex,
+        endIndex: count
+      });
+      const profileMessages = rawMessages.map((msg) => ({
+        message: msg,
+        topic: msg.topic ?? "unknown"
+      }));
+      profileMessages.sort((a, b) => Number(b.message.timestamp - a.message.timestamp));
+      setMessages(profileMessages);
+      loadedAddressRef.current = address;
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [address, options.chainId, options.rpcUrl]);
+  useEffect(() => {
+    fetchProfile();
+  }, [fetchProfile]);
+  return { messages, loading: isLoading, error, refetch: fetchProfile };
+}
+var init_useFeedData = __esm({
+  "src/tui/hooks/useFeedData.ts"() {
+  }
+});
+function useKeyboard(options) {
+  const [state, setState] = useState({
+    viewMode: "feeds",
+    selectedFeedIndex: 0,
+    selectedPostIndex: 0,
+    selectedCommentIndex: 0,
+    selectedProfileIndex: 0
+  });
+  const navStackRef = useRef([]);
+  const createSnapshot = useCallback(() => {
+    return {
+      viewMode: state.viewMode,
+      feedName: options.currentFeedName,
+      post: options.currentPost,
+      profileAddress: options.currentProfileAddress,
+      senderFilter: options.currentSenderFilter,
+      selectedFeedIndex: state.selectedFeedIndex,
+      selectedPostIndex: state.selectedPostIndex,
+      selectedCommentIndex: state.selectedCommentIndex,
+      selectedProfileIndex: state.selectedProfileIndex
+    };
+  }, [state, options.currentFeedName, options.currentPost, options.currentProfileAddress, options.currentSenderFilter]);
+  const pushAndNavigate = useCallback((newViewMode, resetIndex) => {
+    navStackRef.current.push(createSnapshot());
+    setState((prev) => {
+      const newState = { ...prev, viewMode: newViewMode };
+      if (resetIndex) {
+        newState[resetIndex.key] = resetIndex.value;
+      }
+      return newState;
+    });
+  }, [createSnapshot]);
+  const navigateUp = useCallback(() => {
+    setState((prev) => {
+      switch (prev.viewMode) {
+        case "feeds":
+          return {
+            ...prev,
+            selectedFeedIndex: Math.max(0, prev.selectedFeedIndex - 1)
+          };
+        case "posts":
+          return {
+            ...prev,
+            selectedPostIndex: Math.max(0, prev.selectedPostIndex - 1)
+          };
+        case "comments":
+          return {
+            ...prev,
+            selectedCommentIndex: Math.max(0, prev.selectedCommentIndex - 1)
+          };
+        case "profile":
+          return {
+            ...prev,
+            selectedProfileIndex: Math.max(0, prev.selectedProfileIndex - 1)
+          };
+        default:
+          return prev;
+      }
+    });
+  }, []);
+  const navigateDown = useCallback(() => {
+    setState((prev) => {
+      switch (prev.viewMode) {
+        case "feeds":
+          return {
+            ...prev,
+            selectedFeedIndex: Math.min(
+              options.feedsCount - 1,
+              prev.selectedFeedIndex + 1
+            )
+          };
+        case "posts":
+          return {
+            ...prev,
+            selectedPostIndex: Math.min(
+              options.postsCount - 1,
+              prev.selectedPostIndex + 1
+            )
+          };
+        case "comments":
+          return {
+            ...prev,
+            selectedCommentIndex: Math.min(
+              options.commentsCount - 1,
+              prev.selectedCommentIndex + 1
+            )
+          };
+        case "profile":
+          return {
+            ...prev,
+            selectedProfileIndex: Math.min(
+              options.profileItemsCount - 1,
+              prev.selectedProfileIndex + 1
+            )
+          };
+        default:
+          return prev;
+      }
+    });
+  }, [options.feedsCount, options.postsCount, options.commentsCount, options.profileItemsCount]);
+  const selectItem = useCallback(() => {
+    switch (state.viewMode) {
+      case "feeds":
+        if (options.onSelectFeed) {
+          options.onSelectFeed(state.selectedFeedIndex);
+        }
+        pushAndNavigate("posts", { key: "selectedPostIndex", value: 0 });
+        break;
+      case "posts":
+        if (options.onSelectPost) {
+          options.onSelectPost(state.selectedPostIndex);
+        }
+        pushAndNavigate("comments", { key: "selectedCommentIndex", value: 0 });
+        break;
+      case "profile":
+        if (options.onSelectProfileItem) {
+          options.onSelectProfileItem(state.selectedProfileIndex);
+        }
+        pushAndNavigate("posts", { key: "selectedPostIndex", value: 0 });
+        break;
+    }
+  }, [state.viewMode, state.selectedFeedIndex, state.selectedPostIndex, state.selectedProfileIndex, options.onSelectFeed, options.onSelectPost, options.onSelectProfileItem, pushAndNavigate]);
+  const goBack = useCallback(() => {
+    if (state.viewMode === "compose" || state.viewMode === "filter") {
+      setState((prev) => ({ ...prev, viewMode: "posts" }));
+      return;
+    }
+    const previousEntry = navStackRef.current.pop();
+    if (previousEntry && options.onRestoreState) {
+      options.onRestoreState(previousEntry);
+      setState({
+        viewMode: previousEntry.viewMode,
+        selectedFeedIndex: previousEntry.selectedFeedIndex,
+        selectedPostIndex: previousEntry.selectedPostIndex,
+        selectedCommentIndex: previousEntry.selectedCommentIndex,
+        selectedProfileIndex: previousEntry.selectedProfileIndex
+      });
+    } else if (state.viewMode !== "feeds") {
+      setState((prev) => ({ ...prev, viewMode: "feeds" }));
+    }
+  }, [state.viewMode, options.onRestoreState]);
+  useCallback(() => {
+    if (options.onCompose) {
+      setState((prev) => ({ ...prev, viewMode: "compose" }));
+      options.onCompose();
+    }
+  }, [options.onCompose]);
+  const startFilter = useCallback(() => {
+    if (options.onFilter) {
+      setState((prev) => ({ ...prev, viewMode: "filter" }));
+      options.onFilter();
+    }
+  }, [options.onFilter]);
+  const startSearch = useCallback(() => {
+    if (options.onSearch) {
+      navStackRef.current.push(createSnapshot());
+      setState((prev) => ({ ...prev, viewMode: "search" }));
+      options.onSearch();
+    }
+  }, [options.onSearch, createSnapshot]);
+  const viewProfile = useCallback(() => {
+    if (options.onViewProfile) {
+      pushAndNavigate("profile", { key: "selectedProfileIndex", value: 0 });
+      options.onViewProfile();
+    }
+  }, [options.onViewProfile, pushAndNavigate]);
+  const goHome = useCallback(() => {
+    navStackRef.current = [];
+    if (options.onGoHome) {
+      options.onGoHome();
+    }
+    setState({
+      viewMode: "feeds",
+      selectedFeedIndex: 0,
+      selectedPostIndex: 0,
+      selectedCommentIndex: 0,
+      selectedProfileIndex: 0
+    });
+  }, [options.onGoHome]);
+  useInput((input, key) => {
+    if (state.viewMode === "compose" || state.viewMode === "filter" || state.viewMode === "search") return;
+    if (input === "q") {
+      options.onQuit();
+    } else if (input === "j" || key.downArrow) {
+      navigateDown();
+    } else if (input === "k" || key.upArrow) {
+      navigateUp();
+    } else if (key.return) {
+      selectItem();
+    } else if (key.escape) {
+      goBack();
+    } else if (input === "r") {
+      options.onRefresh();
+    } else if (input === "h") {
+      goHome();
+    } else if (input === "/") {
+      startSearch();
+    } else if (input === "p" && (state.viewMode === "posts" || state.viewMode === "comments")) {
+      viewProfile();
+    } else if (input === "f" && state.viewMode === "posts") {
+      startFilter();
+    } else if (input === "u" && state.viewMode === "posts") {
+      if (options.onToggleUserFilter) {
+        options.onToggleUserFilter();
+      }
+    } else if (input === "?") {
+      if (options.onShowHelp) {
+        options.onShowHelp();
+      }
+    }
+  });
+  const setViewMode = useCallback((mode) => {
+    setState((prev) => ({ ...prev, viewMode: mode }));
+  }, []);
+  return {
+    ...state,
+    setViewMode,
+    navigateUp,
+    navigateDown,
+    selectItem,
+    goBack
+  };
+}
+var init_useKeyboard = __esm({
+  "src/tui/hooks/useKeyboard.ts"() {
+  }
+});
+function useViewport({
+  itemCount,
+  selectedIndex,
+  reservedLines = 6,
+  // header, status bar, padding, etc.
+  linesPerItem = 3
+  // most items are 2-3 lines (content + metadata + margin)
+}) {
+  const { stdout } = useStdout();
+  const [terminalHeight, setTerminalHeight] = useState(stdout?.rows ?? 24);
+  useEffect(() => {
+    if (!stdout) return;
+    const handleResize = () => {
+      setTerminalHeight(stdout.rows);
+    };
+    setTerminalHeight(stdout.rows);
+    stdout.on("resize", handleResize);
+    return () => {
+      stdout.off("resize", handleResize);
+    };
+  }, [stdout]);
+  const availableHeight = Math.max(terminalHeight - reservedLines, 5);
+  const visibleItemCount = Math.max(Math.floor(availableHeight / linesPerItem), 1);
+  let startIndex = Math.max(0, selectedIndex - Math.floor(visibleItemCount / 2));
+  if (startIndex + visibleItemCount > itemCount) {
+    startIndex = Math.max(0, itemCount - visibleItemCount);
+  }
+  const endIndex = Math.min(startIndex + visibleItemCount, itemCount);
+  return {
+    terminalHeight,
+    availableHeight,
+    startIndex,
+    endIndex
+  };
+}
+var init_useViewport = __esm({
+  "src/tui/hooks/useViewport.ts"() {
+  }
+});
+
+// src/tui/hooks/index.ts
+var init_hooks = __esm({
+  "src/tui/hooks/index.ts"() {
+    init_useFeedData();
+    init_useKeyboard();
+    init_useViewport();
+  }
+});
+function FeedList({
+  feeds,
+  selectedIndex,
+  loading,
+  error
+}) {
+  const { startIndex, endIndex } = useViewport({
+    itemCount: feeds.length,
+    selectedIndex,
+    reservedLines: 7,
+    // header + hint + status bar + padding
+    linesPerItem: 1
+  });
+  if (loading) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "Loading feeds..." }) });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsxs(Text, { color: "red", children: [
+      "Error: ",
+      error.message
+    ] }) });
+  }
+  const visibleFeeds = feeds.slice(startIndex, endIndex);
+  const hasMoreAbove = startIndex > 0;
+  const hasMoreBelow = endIndex < feeds.length;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, color: "cyan", children: [
+      "Registered Feeds ",
+      feeds.length > 0 && `(${feeds.length})`
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: 'Press "/" to search any feed or profile' }) }),
+    hasMoreAbove && /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+      "  \u2191 ",
+      startIndex,
+      " more above"
+    ] }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: hasMoreAbove ? 0 : 1, children: feeds.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "gray", children: "No registered feeds found" }) : visibleFeeds.map((feed, index) => {
+      const actualIndex = startIndex + index;
+      const isSelected = actualIndex === selectedIndex;
+      return /* @__PURE__ */ jsxs(
+        Text,
+        {
+          color: isSelected ? "green" : void 0,
+          bold: isSelected,
+          children: [
+            isSelected ? "\u25B6 " : "  ",
+            feed.feedName
+          ]
+        },
+        `${feed.feedName}-${actualIndex}`
+      );
+    }) }),
+    hasMoreBelow && /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+      "  \u2193 ",
+      feeds.length - endIndex,
+      " more below"
+    ] })
+  ] });
+}
+var init_FeedList = __esm({
+  "src/tui/components/FeedList.tsx"() {
+    init_hooks();
+  }
+});
+function truncateAddress2(address) {
+  if (address.length <= 12) return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function isAddress(str) {
+  return /^0x[a-fA-F0-9]{40}$/.test(str);
+}
+function formatFeedName(feedName) {
+  let name = feedName;
+  if (name.startsWith("feed-")) {
+    name = name.slice(5);
+  }
+  if (isAddress(name)) {
+    return `@${truncateAddress2(name)}`;
+  }
+  return name;
+}
+function formatTimestamp2(timestamp) {
+  const date = new Date(Number(timestamp) * 1e3);
+  return date.toLocaleString("en-US", {
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function parsePostContent(text) {
+  if (!text) return { title: "", body: null };
+  const firstNewline = text.indexOf("\n");
+  if (firstNewline === -1) {
+    return { title: text.trim(), body: null };
+  }
+  const title = text.slice(0, firstNewline).trim();
+  const body = text.slice(firstNewline + 1).trim();
+  return { title, body: body || null };
+}
+function truncateTitle(title, maxLength = 70) {
+  if (title.length <= maxLength) return title;
+  return title.slice(0, maxLength - 3) + "...";
+}
+function PostList({
+  feedName,
+  posts,
+  commentCounts,
+  selectedIndex,
+  loading,
+  error
+}) {
+  const { startIndex, endIndex } = useViewport({
+    itemCount: posts.length,
+    selectedIndex,
+    reservedLines: 6,
+    // header + status bar + padding
+    linesPerItem: 3
+    // title + metadata + margin
+  });
+  if (loading) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "Loading posts..." }) });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsxs(Text, { color: "red", children: [
+      "Error: ",
+      error.message
+    ] }) });
+  }
+  if (posts.length === 0) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      "No posts in ",
+      formatFeedName(feedName)
+    ] }) });
+  }
+  const visiblePosts = posts.slice(startIndex, endIndex);
+  const hasMoreAbove = startIndex > 0;
+  const hasMoreBelow = endIndex < posts.length;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, color: "cyan", children: [
+      formatFeedName(feedName),
+      " (",
+      posts.length,
+      " posts)"
+    ] }),
+    hasMoreAbove && /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+      "  \u2191 ",
+      startIndex,
+      " more above"
+    ] }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: hasMoreAbove ? 0 : 1, children: visiblePosts.map((post, index) => {
+      const actualIndex = startIndex + index;
+      const isSelected = actualIndex === selectedIndex;
+      const postKey = `${post.sender}:${post.timestamp}`;
+      const commentCount = commentCounts.get(postKey) ?? 0;
+      const { title, body } = parsePostContent(post.text);
+      const displayTitle = title ? truncateTitle(title) : null;
+      const hasMore = body !== null;
+      return /* @__PURE__ */ jsxs(
+        Box,
+        {
+          flexDirection: "column",
+          marginBottom: 1,
+          children: [
+            /* @__PURE__ */ jsxs(
+              Text,
+              {
+                color: isSelected ? "green" : void 0,
+                bold: isSelected,
+                children: [
+                  isSelected ? "\u25B6 " : "  ",
+                  displayTitle || /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "(no text)" }),
+                  hasMore && /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: " [...]" })
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+              "    ",
+              truncateAddress2(post.sender),
+              " \xB7 ",
+              formatTimestamp2(post.timestamp),
+              " \xB7 ",
+              commentCount,
+              " comment",
+              commentCount !== 1 ? "s" : ""
+            ] })
+          ]
+        },
+        postKey
+      );
+    }) }),
+    hasMoreBelow && /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+      "  \u2193 ",
+      posts.length - endIndex,
+      " more below"
+    ] })
+  ] });
+}
+var init_PostList = __esm({
+  "src/tui/components/PostList.tsx"() {
+    init_hooks();
+  }
+});
+function truncateAddress3(address) {
+  if (address.length <= 12) return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function formatTimestamp3(timestamp) {
+  const date = new Date(Number(timestamp) * 1e3);
+  return date.toLocaleString("en-US", {
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function collapseText(text, maxLength = 80) {
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  if (collapsed.length <= maxLength) return collapsed;
+  return collapsed.slice(0, maxLength - 3) + "...";
+}
+function getTextLines(text, width) {
+  const lines = [];
+  const rawLines = text.split("\n");
+  for (const rawLine of rawLines) {
+    if (rawLine.length === 0) {
+      lines.push("");
+    } else if (rawLine.length <= width) {
+      lines.push(rawLine);
+    } else {
+      let remaining = rawLine;
+      while (remaining.length > 0) {
+        lines.push(remaining.slice(0, width));
+        remaining = remaining.slice(width);
+      }
+    }
+  }
+  return lines;
+}
+function CommentTree({
+  post,
+  comments,
+  replyCounts,
+  selectedIndex,
+  loading,
+  error
+}) {
+  const { stdout } = useStdout();
+  const terminalHeight = stdout?.rows ?? 24;
+  const terminalWidth = stdout?.columns ?? 80;
+  const reservedLines = 6;
+  const availableHeight = terminalHeight - reservedLines;
+  const isPostSelected = selectedIndex === 0;
+  const selectedCommentIndex = selectedIndex - 1;
+  if (loading) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "Loading post..." }) });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsxs(Text, { color: "red", children: [
+      "Error: ",
+      error.message
+    ] }) });
+  }
+  const contentWidth = Math.max(40, terminalWidth - 8);
+  const postText = post.text ?? "";
+  const postLines = getTextLines(postText, contentWidth);
+  const linesPerComment = 3;
+  const maxPostLines = isPostSelected ? Math.max(3, availableHeight - 6) : 3;
+  const displayPostLines = postLines.slice(0, maxPostLines);
+  const postHasMore = postLines.length > maxPostLines;
+  const postOverhead = 1 + displayPostLines.length + 1 + (postHasMore ? 1 : 0) + 1 + 2;
+  const linesForComments = Math.max(3, availableHeight - postOverhead);
+  const visibleCommentCount = Math.floor(linesForComments / linesPerComment);
+  let commentStartIndex = 0;
+  if (selectedCommentIndex > 0) {
+    commentStartIndex = Math.max(0, selectedCommentIndex - Math.floor(visibleCommentCount / 2));
+    if (commentStartIndex + visibleCommentCount > comments.length) {
+      commentStartIndex = Math.max(0, comments.length - visibleCommentCount);
+    }
+  }
+  const commentEndIndex = Math.min(commentStartIndex + visibleCommentCount, comments.length);
+  const visibleComments = comments.slice(commentStartIndex, commentEndIndex);
+  const hasMoreCommentsAbove = commentStartIndex > 0;
+  const hasMoreCommentsBelow = commentEndIndex < comments.length;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "Post" }),
+    /* @__PURE__ */ jsxs(Box, { marginLeft: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: isPostSelected ? "green" : void 0, bold: isPostSelected, children: isPostSelected ? "\u25B6 " : "  " }),
+      /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: contentWidth, children: [
+        displayPostLines.length === 0 ? /* @__PURE__ */ jsx(Text, { color: "gray", children: "(no text)" }) : displayPostLines.map((line, i) => /* @__PURE__ */ jsx(Text, { color: isPostSelected ? "green" : void 0, wrap: "truncate-end", children: line || " " }, i)),
+        postHasMore && /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+          isPostSelected ? "\u2193 " : "\u2191 ",
+          postLines.length - maxPostLines,
+          " more lines"
+        ] })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+      "   ",
+      truncateAddress3(post.sender),
+      " \xB7 ",
+      formatTimestamp3(post.timestamp)
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsxs(Text, { bold: true, color: "cyan", children: [
+      "Comments (",
+      comments.length,
+      ")"
+    ] }) }),
+    comments.length === 0 ? /* @__PURE__ */ jsx(Box, { marginTop: 1, marginLeft: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: "No comments yet" }) }) : /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      hasMoreCommentsAbove && /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+        "    \u2191 ",
+        commentStartIndex,
+        " more above"
+      ] }),
+      visibleComments.map((item, index) => {
+        const actualIndex = commentStartIndex + index;
+        const isSelected = actualIndex === selectedCommentIndex;
+        const { comment, depth } = item;
+        const key = `${comment.sender}:${comment.timestamp}`;
+        const replyCount = replyCounts.get(key) ?? 0;
+        const displayText = comment.text ? collapseText(comment.text) : null;
+        const indent = "  ".repeat(depth);
+        const replyIndicator = depth > 0 ? "\u21B3 " : "";
+        return /* @__PURE__ */ jsxs(
+          Box,
+          {
+            flexDirection: "column",
+            marginLeft: 1,
+            marginBottom: 1,
+            children: [
+              /* @__PURE__ */ jsxs(
+                Text,
+                {
+                  color: isSelected ? "green" : void 0,
+                  bold: isSelected,
+                  children: [
+                    indent,
+                    isSelected ? "\u25B6 " : "  ",
+                    replyIndicator,
+                    displayText || /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "(no text)" })
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+                indent,
+                "    ",
+                truncateAddress3(comment.sender),
+                " \xB7 ",
+                formatTimestamp3(comment.timestamp),
+                replyCount > 0 && ` \xB7 ${replyCount} ${replyCount === 1 ? "reply" : "replies"}`
+              ] })
+            ]
+          },
+          key
+        );
+      }),
+      hasMoreCommentsBelow && /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+        "    \u2193 ",
+        comments.length - commentEndIndex,
+        " more below"
+      ] })
+    ] })
+  ] });
+}
+var init_CommentTree = __esm({
+  "src/tui/components/CommentTree.tsx"() {
+  }
+});
+function truncateAddress4(address) {
+  if (address.length <= 12) return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function cleanFeedName(topic) {
+  let clean = topic.split(":comments:")[0];
+  if (clean.startsWith("feed-")) {
+    clean = clean.slice(5);
+  }
+  return clean;
+}
+function aggregateByFeed(messages) {
+  const feedMap = /* @__PURE__ */ new Map();
+  for (const { message, topic } of messages) {
+    if (topic.includes(":comments:")) {
+      continue;
+    }
+    const feedName = cleanFeedName(topic);
+    const existing = feedMap.get(feedName);
+    if (existing) {
+      existing.postCount++;
+      if (message.timestamp > existing.lastActive) {
+        existing.lastActive = message.timestamp;
+      }
+    } else {
+      feedMap.set(feedName, {
+        topic,
+        // Keep original topic for navigation
+        feedName,
+        postCount: 1,
+        lastActive: message.timestamp
+      });
+    }
+  }
+  return Array.from(feedMap.values()).sort(
+    (a, b) => Number(b.lastActive - a.lastActive)
+  );
+}
+function Profile({
+  address,
+  activityMessages,
+  loading,
+  error,
+  selectedIndex
+}) {
+  const aggregatedFeeds = React5.useMemo(
+    () => aggregateByFeed(activityMessages),
+    [activityMessages]
+  );
+  const totalItems = 1 + aggregatedFeeds.length;
+  const { startIndex, endIndex } = useViewport({
+    itemCount: totalItems,
+    selectedIndex,
+    reservedLines: 6,
+    linesPerItem: 2
+  });
+  if (loading) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsx(Text, { color: "yellow", children: "Loading profile..." }) });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", padding: 1, children: /* @__PURE__ */ jsxs(Text, { color: "red", children: [
+      "Error: ",
+      error.message
+    ] }) });
+  }
+  const hasMoreAbove = startIndex > 0;
+  const hasMoreBelow = endIndex < totalItems;
+  const visibleItems = [];
+  for (let i = startIndex; i < endIndex; i++) {
+    const isSelected = i === selectedIndex;
+    if (i === 0) {
+      visibleItems.push(
+        /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs(
+          Text,
+          {
+            color: isSelected ? "green" : void 0,
+            bold: isSelected,
+            children: [
+              isSelected ? "\u25B6 " : "  ",
+              /* @__PURE__ */ jsxs(Text, { color: isSelected ? "green" : "magenta", children: [
+                "@",
+                truncateAddress4(address)
+              ] }),
+              /* @__PURE__ */ jsx(Text, { color: "gray", children: " \xB7 view their feed" })
+            ]
+          }
+        ) }, "their-feed")
+      );
+    } else {
+      const feed = aggregatedFeeds[i - 1];
+      if (feed) {
+        const postLabel = `${feed.postCount} post${feed.postCount !== 1 ? "s" : ""}`;
+        visibleItems.push(
+          /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs(
+            Text,
+            {
+              color: isSelected ? "green" : void 0,
+              bold: isSelected,
+              children: [
+                isSelected ? "\u25B6 " : "  ",
+                /* @__PURE__ */ jsx(Text, { color: isSelected ? "green" : "cyan", children: feed.feedName }),
+                /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+                  " \xB7 ",
+                  postLabel
+                ] })
+              ]
+            }
+          ) }, feed.topic)
+        );
+      }
+    }
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: truncateAddress4(address) }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Their Feed" }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: " \xB7 " }),
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "Active On (",
+        aggregatedFeeds.length,
+        ")"
+      ] })
+    ] }),
+    hasMoreAbove && /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+      "  \u2191 ",
+      startIndex,
+      " more above"
+    ] }),
+    /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: hasMoreAbove ? 0 : 0, children: visibleItems }),
+    hasMoreBelow && /* @__PURE__ */ jsxs(Text, { color: "gray", dimColor: true, children: [
+      "  \u2193 ",
+      totalItems - endIndex,
+      " more below"
+    ] })
+  ] });
+}
+var init_Profile = __esm({
+  "src/tui/components/Profile.tsx"() {
+    init_hooks();
+  }
+});
+function truncateAddress5(address) {
+  if (address.length <= 12) return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function isAddress2(str) {
+  return /^0x[a-fA-F0-9]{40}$/.test(str);
+}
+function formatFeedName2(feedName) {
+  let name = feedName;
+  if (name.startsWith("feed-")) {
+    name = name.slice(5);
+  }
+  if (isAddress2(name)) {
+    return `@${truncateAddress5(name)}`;
+  }
+  return name;
+}
+function getChainName(chainId) {
+  switch (chainId) {
+    case 1:
+      return "mainnet";
+    case 8453:
+      return "base";
+    case 84532:
+      return "base-sepolia";
+    default:
+      return `chain:${chainId}`;
+  }
+}
+function Header({ viewMode, chainId, feedName, senderFilter, profileAddress }) {
+  const getBreadcrumb = () => {
+    const parts = [];
+    if (viewMode === "profile" && profileAddress) {
+      parts.push(/* @__PURE__ */ jsx(Text, { color: "white", children: "profile" }, "profile"));
+      parts.push(/* @__PURE__ */ jsx(Text, { color: "gray", children: " \xB7 " }, "sep"));
+      parts.push(/* @__PURE__ */ jsx(Text, { color: "magenta", children: truncateAddress5(profileAddress) }, "address"));
+    } else if (viewMode === "feeds" || viewMode === "search") {
+      parts.push(/* @__PURE__ */ jsx(Text, { color: "white", children: "home" }, "home"));
+    } else if (feedName) {
+      parts.push(/* @__PURE__ */ jsx(Text, { color: "white", children: formatFeedName2(feedName) }, "feed"));
+      if (viewMode === "comments") {
+        parts.push(/* @__PURE__ */ jsx(Text, { color: "gray", children: " > " }, "sep"));
+        parts.push(/* @__PURE__ */ jsx(Text, { color: "white", children: "post" }, "post"));
+      }
+    }
+    if (senderFilter && viewMode !== "profile") {
+      parts.push(/* @__PURE__ */ jsx(Text, { color: "gray", children: " " }, "filter-sep"));
+      parts.push(/* @__PURE__ */ jsxs(Text, { color: "magenta", children: [
+        "[",
+        truncateAddress5(senderFilter),
+        "]"
+      ] }, "filter"));
+    }
+    return parts;
+  };
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      borderStyle: "single",
+      borderColor: "cyan",
+      paddingX: 1,
+      justifyContent: "space-between",
+      children: [
+        /* @__PURE__ */ jsxs(Box, { children: [
+          /* @__PURE__ */ jsx(Text, { color: "cyan", bold: true, children: "botchan" }),
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: " \xB7 " }),
+          /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "onchain messaging for agents" })
+        ] }),
+        /* @__PURE__ */ jsxs(Box, { children: [
+          getBreadcrumb(),
+          /* @__PURE__ */ jsx(Text, { color: "gray", children: " \xB7 " }),
+          /* @__PURE__ */ jsx(Text, { color: "green", children: getChainName(chainId) })
+        ] })
+      ]
+    }
+  );
+}
+var init_Header = __esm({
+  "src/tui/components/Header.tsx"() {
+  }
+});
+function StatusBar({ viewMode }) {
+  const getContextHints = () => {
+    switch (viewMode) {
+      case "feeds":
+        return "j/k navigate \xB7 enter select \xB7 / search \xB7 r refresh \xB7 ? help \xB7 q quit";
+      case "posts":
+        return "j/k navigate \xB7 enter view \xB7 p profile \xB7 u toggle user \xB7 f filter \xB7 ? help \xB7 q quit";
+      case "comments":
+        return "j/k navigate \xB7 p profile \xB7 esc back \xB7 ? help \xB7 q quit";
+      case "profile":
+        return "j/k navigate \xB7 enter select \xB7 esc back \xB7 ? help \xB7 q quit";
+      case "compose":
+        return "type message \xB7 enter submit \xB7 esc cancel";
+      case "filter":
+        return "enter address \xB7 enter apply \xB7 esc cancel";
+      case "search":
+        return "enter feed name \xB7 enter go \xB7 esc cancel";
+      default:
+        return "";
+    }
+  };
+  return /* @__PURE__ */ jsx(Box, { paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", children: getContextHints() }) });
+}
+var init_StatusBar = __esm({
+  "src/tui/components/StatusBar.tsx"() {
+  }
+});
+function PostInput({ feedName, onSubmit, onCancel }) {
+  const [text, setText] = useState("");
+  useInput((input, key) => {
+    if (key.escape) {
+      onCancel();
+    } else if (key.return) {
+      if (text.trim()) {
+        onSubmit(text.trim());
+      }
+    } else if (key.backspace || key.delete) {
+      setText((prev) => prev.slice(0, -1));
+    } else if (input && !key.ctrl && !key.meta) {
+      setText((prev) => prev + input);
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, color: "cyan", children: [
+      "New Post to ",
+      feedName
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Enter your message (Esc to cancel):" }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, borderStyle: "single", borderColor: "gray", padding: 1, children: /* @__PURE__ */ jsxs(Text, { children: [
+        text,
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u2588" })
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "Press Enter to submit" }) })
+  ] });
+}
+var init_PostInput = __esm({
+  "src/tui/components/PostInput.tsx"() {
+  }
+});
+function SenderFilter({ onSubmit, onCancel }) {
+  const [text, setText] = useState("");
+  useInput((input, key) => {
+    if (key.escape) {
+      onCancel();
+    } else if (key.return) {
+      const trimmed = text.trim();
+      onSubmit(trimmed ? trimmed.toLowerCase() : "");
+    } else if (key.backspace || key.delete) {
+      setText((prev) => prev.slice(0, -1));
+    } else if (input && !key.ctrl && !key.meta) {
+      setText((prev) => prev + input);
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "Filter by Sender Address" }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Enter address (or empty to clear filter):" }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, borderStyle: "single", borderColor: "gray", padding: 1, children: /* @__PURE__ */ jsxs(Text, { children: [
+        text || /* @__PURE__ */ jsx(Text, { color: "gray", children: "0x..." }),
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u2588" })
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "Enter: apply filter | Esc: cancel" }) })
+  ] });
+}
+var init_SenderFilter = __esm({
+  "src/tui/components/SenderFilter.tsx"() {
+  }
+});
+function FeedSearch({ onSubmit, onCancel }) {
+  const [text, setText] = useState("");
+  useInput((input, key) => {
+    if (key.escape) {
+      onCancel();
+    } else if (key.return) {
+      if (text.trim()) {
+        onSubmit(normalizeFeedName(text.trim()));
+      }
+    } else if (key.backspace || key.delete) {
+      setText((prev) => prev.slice(0, -1));
+    } else if (input && !key.ctrl && !key.meta) {
+      setText((prev) => prev + input);
+    }
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "Go to Feed or Profile" }),
+    /* @__PURE__ */ jsxs(Box, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: "Enter feed name or wallet address:" }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "(Feeds don't need to be registered to view them)" }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, borderStyle: "single", borderColor: "gray", padding: 1, children: /* @__PURE__ */ jsxs(Text, { children: [
+        text || /* @__PURE__ */ jsx(Text, { color: "gray", children: "general, 0x1234..., etc" }),
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "\u2588" })
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "Enter: go to feed | Esc: cancel" }) })
+  ] });
+}
+var init_FeedSearch = __esm({
+  "src/tui/components/FeedSearch.tsx"() {
+    init_utils();
+  }
+});
+function Help({ onClose }) {
+  useInput(() => {
+    onClose();
+  });
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "botchan" }),
+      /* @__PURE__ */ jsx(Text, { color: "gray", children: " \xB7 onchain messaging for agents" })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: "Navigation" }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "j/k \u2191/\u2193" }),
+        "    Move up/down"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "enter" }),
+        "      Select / view"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "esc" }),
+        "        Go back"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "h" }),
+        "          Go home"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "q" }),
+        "          Quit"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx(Text, { bold: true, color: "white", children: "Actions" }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "p" }),
+        "          View author profile"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "u" }),
+        "          Toggle user filter"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "f" }),
+        "          Filter by address"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "/" }),
+        "          Search feeds"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "r" }),
+        "          Refresh"
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "  ",
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: "?" }),
+        "          Show this help"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { color: "gray", dimColor: true, children: "Press any key to close" }) })
+  ] });
+}
+var init_Help = __esm({
+  "src/tui/components/Help.tsx"() {
+  }
+});
+
+// src/tui/components/index.ts
+var init_components = __esm({
+  "src/tui/components/index.ts"() {
+    init_FeedList();
+    init_PostList();
+    init_CommentTree();
+    init_Profile();
+    init_Header();
+    init_StatusBar();
+    init_PostInput();
+    init_SenderFilter();
+    init_FeedSearch();
+    init_Help();
+  }
+});
+function App({ chainId, rpcUrl, onExit }) {
+  const { stdout } = useStdout();
+  const terminalHeight = stdout?.rows ?? 24;
+  const [selectedFeedName, setSelectedFeedName] = useState(null);
+  const [selectedPost, setSelectedPost] = useState(null);
+  const [profileAddress, setProfileAddress] = useState(null);
+  const [isComposing, setIsComposing] = useState(false);
+  const [isFiltering, setIsFiltering] = useState(false);
+  const [isSearching, setIsSearching] = useState(false);
+  const [isShowingHelp, setIsShowingHelp] = useState(false);
+  const [senderFilter, setSenderFilter] = useState(void 0);
+  const feedDataOptions = { chainId, rpcUrl, senderFilter };
+  const {
+    feeds,
+    loading: feedsLoading,
+    error: feedsError,
+    refetch: refetchFeeds
+  } = useFeeds({ chainId, rpcUrl });
+  const {
+    posts: rawPosts,
+    commentCounts,
+    loading: postsLoading,
+    error: postsError,
+    refetch: refetchPosts
+  } = usePosts(selectedFeedName, feedDataOptions);
+  const posts = React5.useMemo(
+    () => [...rawPosts].sort((a, b) => Number(b.timestamp - a.timestamp)),
+    [rawPosts]
+  );
+  const {
+    comments,
+    replyCounts,
+    loading: commentsLoading,
+    error: commentsError,
+    refetch: refetchComments
+  } = useComments(selectedPost, feedDataOptions);
+  const {
+    messages: profileMessages,
+    loading: profileLoading,
+    error: profileError,
+    refetch: refetchProfile
+  } = useProfile(profileAddress, { chainId, rpcUrl });
+  const aggregatedFeeds = React5.useMemo(
+    () => aggregateByFeed(profileMessages),
+    [profileMessages]
+  );
+  const handleRefresh = useCallback(() => {
+    if (profileAddress) {
+      refetchProfile();
+    } else if (selectedPost) {
+      refetchComments();
+    } else if (selectedFeedName) {
+      refetchPosts();
+    } else {
+      refetchFeeds();
+    }
+  }, [profileAddress, selectedPost, selectedFeedName, refetchProfile, refetchComments, refetchPosts, refetchFeeds]);
+  const handleCompose = useCallback(() => {
+    if (selectedFeedName) {
+      setIsComposing(true);
+    }
+  }, [selectedFeedName]);
+  const handleFilter = useCallback(() => {
+    setIsFiltering(true);
+  }, []);
+  const handleSearch = useCallback(() => {
+    setIsSearching(true);
+  }, []);
+  const handleShowHelp = useCallback(() => {
+    setIsShowingHelp(true);
+  }, []);
+  const handleSelectFeed = useCallback((index) => {
+    if (feeds[index]) {
+      setSelectedFeedName(feeds[index].feedName);
+      setSenderFilter(void 0);
+    }
+  }, [feeds]);
+  const handleSelectPost = useCallback((index) => {
+    if (posts[index]) {
+      setSelectedPost(posts[index]);
+    }
+  }, [posts]);
+  const selectedPostIndexRef = React5.useRef(0);
+  const selectedCommentIndexRef = React5.useRef(0);
+  const handleViewProfile = useCallback(() => {
+    if (selectedPost) {
+      const index = selectedCommentIndexRef.current;
+      if (index === 0) {
+        setProfileAddress(selectedPost.sender);
+      } else {
+        const commentIndex = index - 1;
+        if (comments[commentIndex]) {
+          setProfileAddress(comments[commentIndex].comment.sender);
+        }
+      }
+    } else if (posts.length > 0) {
+      const postIndex = selectedPostIndexRef.current;
+      if (posts[postIndex]) {
+        setProfileAddress(posts[postIndex].sender);
+      }
+    }
+  }, [selectedPost, posts, comments]);
+  const handleSelectProfileItem = useCallback((index) => {
+    if (index === 0) {
+      if (profileAddress) {
+        setSelectedFeedName(profileAddress);
+        setSenderFilter(void 0);
+        setProfileAddress(null);
+      }
+    } else {
+      const feedIndex = index - 1;
+      if (aggregatedFeeds[feedIndex]) {
+        const topic = aggregatedFeeds[feedIndex].topic;
+        setSelectedFeedName(topic);
+        setSenderFilter(profileAddress ?? void 0);
+        setProfileAddress(null);
+      }
+    }
+  }, [aggregatedFeeds, profileAddress]);
+  const handleGoHome = useCallback(() => {
+    setSelectedFeedName(null);
+    setSelectedPost(null);
+    setProfileAddress(null);
+    setSenderFilter(void 0);
+  }, []);
+  const handleToggleUserFilter = useCallback(() => {
+    if (senderFilter) {
+      setSenderFilter(void 0);
+    } else {
+      const postIndex = selectedPostIndexRef.current;
+      if (posts[postIndex]) {
+        setSenderFilter(posts[postIndex].sender);
+      }
+    }
+  }, [senderFilter, posts]);
+  const handleRestoreState = useCallback((entry) => {
+    setSelectedFeedName(entry.feedName);
+    setSelectedPost(entry.post);
+    setProfileAddress(entry.profileAddress);
+    setSenderFilter(entry.senderFilter);
+  }, []);
+  const profileItemsCount = 1 + aggregatedFeeds.length;
+  const {
+    viewMode,
+    selectedFeedIndex,
+    selectedPostIndex,
+    selectedCommentIndex,
+    selectedProfileIndex,
+    setViewMode,
+    goBack
+  } = useKeyboard({
+    feedsCount: feeds.length,
+    postsCount: posts.length,
+    commentsCount: 1 + comments.length,
+    // +1 for the post itself
+    profileItemsCount,
+    // Current context for stack snapshots
+    currentFeedName: selectedFeedName,
+    currentPost: selectedPost,
+    currentProfileAddress: profileAddress,
+    currentSenderFilter: senderFilter,
+    // Callbacks
+    onQuit: onExit,
+    onRefresh: handleRefresh,
+    onCompose: handleCompose,
+    onFilter: handleFilter,
+    onSearch: handleSearch,
+    onSelectFeed: handleSelectFeed,
+    onSelectPost: handleSelectPost,
+    onViewProfile: handleViewProfile,
+    onSelectProfileItem: handleSelectProfileItem,
+    onGoHome: handleGoHome,
+    onRestoreState: handleRestoreState,
+    onToggleUserFilter: handleToggleUserFilter,
+    onShowHelp: handleShowHelp
+  });
+  React5.useEffect(() => {
+    selectedPostIndexRef.current = selectedPostIndex;
+  }, [selectedPostIndex]);
+  React5.useEffect(() => {
+    selectedCommentIndexRef.current = selectedCommentIndex;
+  }, [selectedCommentIndex]);
+  React5.useEffect(() => {
+    if (viewMode === "feeds") {
+      setSelectedFeedName(null);
+      setSelectedPost(null);
+      setProfileAddress(null);
+    } else if (viewMode === "posts") {
+      setSelectedPost(null);
+    }
+  }, [viewMode]);
+  const handleComposeSubmit = useCallback((text) => {
+    console.log(`Would post to ${selectedFeedName}: ${text}`);
+    setIsComposing(false);
+    setViewMode("posts");
+  }, [selectedFeedName, setViewMode]);
+  const handleComposeCancel = useCallback(() => {
+    setIsComposing(false);
+    setViewMode("posts");
+  }, [setViewMode]);
+  const handleFilterSubmit = useCallback((address) => {
+    setSenderFilter(address || void 0);
+    setIsFiltering(false);
+    setViewMode("posts");
+  }, [setViewMode]);
+  const handleFilterCancel = useCallback(() => {
+    setIsFiltering(false);
+    setViewMode("posts");
+  }, [setViewMode]);
+  const handleSearchSubmit = useCallback((feedName) => {
+    setSelectedFeedName(feedName);
+    setSenderFilter(void 0);
+    setIsSearching(false);
+    setViewMode("posts");
+  }, [setViewMode]);
+  const handleSearchCancel = useCallback(() => {
+    setIsSearching(false);
+    goBack();
+  }, [goBack]);
+  const renderContent = () => {
+    if (isShowingHelp) {
+      return /* @__PURE__ */ jsx(Help, { onClose: () => setIsShowingHelp(false) });
+    }
+    if (isComposing && selectedFeedName) {
+      return /* @__PURE__ */ jsx(
+        PostInput,
+        {
+          feedName: selectedFeedName,
+          onSubmit: handleComposeSubmit,
+          onCancel: handleComposeCancel
+        }
+      );
+    }
+    if (isFiltering) {
+      return /* @__PURE__ */ jsx(
+        SenderFilter,
+        {
+          onSubmit: handleFilterSubmit,
+          onCancel: handleFilterCancel
+        }
+      );
+    }
+    if (isSearching) {
+      return /* @__PURE__ */ jsx(
+        FeedSearch,
+        {
+          onSubmit: handleSearchSubmit,
+          onCancel: handleSearchCancel
+        }
+      );
+    }
+    switch (viewMode) {
+      case "feeds":
+        return /* @__PURE__ */ jsx(
+          FeedList,
+          {
+            feeds,
+            selectedIndex: selectedFeedIndex,
+            loading: feedsLoading,
+            error: feedsError
+          }
+        );
+      case "posts":
+        return /* @__PURE__ */ jsx(
+          PostList,
+          {
+            feedName: selectedFeedName ?? "",
+            posts,
+            commentCounts,
+            selectedIndex: selectedPostIndex,
+            loading: postsLoading,
+            error: postsError
+          }
+        );
+      case "comments":
+        if (!selectedPost) {
+          return null;
+        }
+        return /* @__PURE__ */ jsx(
+          CommentTree,
+          {
+            post: selectedPost,
+            comments,
+            replyCounts,
+            selectedIndex: selectedCommentIndex,
+            loading: commentsLoading,
+            error: commentsError
+          }
+        );
+      case "profile":
+        if (!profileAddress) {
+          return null;
+        }
+        return /* @__PURE__ */ jsx(
+          Profile,
+          {
+            address: profileAddress,
+            activityMessages: profileMessages,
+            loading: profileLoading,
+            error: profileError,
+            selectedIndex: selectedProfileIndex
+          }
+        );
+      default:
+        return null;
+    }
+  };
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", height: terminalHeight, children: [
+    /* @__PURE__ */ jsx(
+      Header,
+      {
+        viewMode,
+        chainId,
+        feedName: selectedFeedName,
+        senderFilter,
+        profileAddress
+      }
+    ),
+    /* @__PURE__ */ jsx(Box, { flexGrow: 1, children: renderContent() }),
+    /* @__PURE__ */ jsx(StatusBar, { viewMode })
+  ] });
+}
+var init_App = __esm({
+  "src/tui/App.tsx"() {
+    init_components();
+    init_hooks();
+  }
+});
+
+// src/tui/index.tsx
+var tui_exports = {};
+__export(tui_exports, {
+  launchTui: () => launchTui
+});
+async function launchTui(options) {
+  const chainId = options.chainId ?? DEFAULT_CHAIN_ID;
+  const rpcUrl = options.rpcUrl;
+  console.clear();
+  const { waitUntilExit } = render(
+    /* @__PURE__ */ jsx(App, { chainId, rpcUrl, onExit: () => process.exit(0) })
+  );
+  await waitUntilExit();
+}
+var init_tui = __esm({
+  "src/tui/index.tsx"() {
+    init_App();
+    init_config();
+  }
+});
+
+// src/commands/feeds.ts
+init_utils();
+async function executeFeeds(options) {
+  const readOnlyOptions = parseReadOnlyOptions({
+    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(chalk10.yellow("No registered feeds found"));
+        return;
+      }
+      console.log(chalk10.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 registerFeedsCommand(program2) {
+  program2.command("feeds").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 executeFeeds(options);
+  });
+}
+
+// src/commands/read.ts
+init_utils();
+async function executeRead(feed, options) {
+  const normalizedFeed = normalizeFeedName(feed);
+  const readOnlyOptions = parseReadOnlyOptions({
+    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(chalk10.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(chalk10.yellow(`No posts found in feed "${normalizedFeed}"${senderNote2}`));
+        return;
+      }
+      const senderNote = options.sender ? ` by ${options.sender}` : "";
+      console.log(
+        chalk10.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 registerReadCommand(program2) {
+  program2.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 executeRead(feed, options);
+  });
+}
+
+// src/commands/comments.ts
+init_utils();
+async function executeComments(feed, postId, options) {
+  const normalizedFeed = normalizeFeedName(feed);
+  const readOnlyOptions = parseReadOnlyOptions({
+    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(chalk10.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(chalk10.yellow(`No comments found for post ${postId}`));
+        return;
+      }
+      console.log(
+        chalk10.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 registerCommentsCommand(program2) {
+  program2.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 executeComments(feed, postId, options);
+  });
+}
+
+// src/commands/profile.ts
+init_utils();
+async function executeProfile(address, options) {
+  if (!address.startsWith("0x") || address.length !== 42) {
+    exitWithError("Invalid address format. Must be 0x-prefixed, 42 characters");
+  }
+  const readOnlyOptions = parseReadOnlyOptions({
+    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(chalk10.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(
+        chalk10.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 profile: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerProfileCommand(program2) {
+  program2.command("profile <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 executeProfile(address, options);
+  });
+}
+
+// src/commands/register.ts
+init_utils();
+async function executeRegister(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 = parseReadOnlyOptions({
+      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 = parseCommonOptions(
+    {
+      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(chalk10.blue(`Registering feed "${feedName}"...`));
+  try {
+    const hash = await executeTransaction(walletClient, txConfig);
+    console.log(
+      chalk10.green(
+        `Feed registered successfully!
+  Transaction: ${hash}
+  Feed: ${feedName}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to register feed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerRegisterCommand(program2) {
+  program2.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 executeRegister(feedName, options);
+  });
+}
+
+// src/commands/post.ts
+init_utils();
+var MAX_MESSAGE_LENGTH = 4e3;
+async function executePost(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 = parseReadOnlyOptions({
+      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 = parseCommonOptions(
+    {
+      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(chalk10.blue(`Posting to feed "${normalizedFeed}"...`));
+  try {
+    const hash = await executeTransaction(walletClient, txConfig);
+    const displayText = options.body ? `${message} (+ body)` : message;
+    console.log(
+      chalk10.green(
+        `Message posted successfully!
+  Transaction: ${hash}
+  Feed: ${normalizedFeed}
+  Text: ${displayText}`
+      )
+    );
+  } catch (error) {
+    exitWithError(
+      `Failed to post message: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function registerPostCommand(program2) {
+  program2.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 executePost(feed, message, options);
+  });
+}
+
+// src/commands/comment.ts
+init_utils();
+var MAX_MESSAGE_LENGTH2 = 4e3;
+async function executeComment(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 = parseReadOnlyOptions({
+    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 = parseCommonOptions(
+    {
+      privateKey: options.privateKey,
+      chainId: options.chainId,
+      rpcUrl: options.rpcUrl
+    },
+    true
+    // supports --encode-only
+  );
+  const walletClient = createWallet(
+    commonOptions.privateKey,
+    commonOptions.chainId,
+    commonOptions.rpcUrl
+  );
+  console.log(chalk10.blue(`Commenting on post ${postId}...`));
+  try {
+    const hash = await executeTransaction(walletClient, txConfig);
+    console.log(
+      chalk10.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 registerCommentCommand(program2) {
+  program2.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 executeComment(feed, postId, message, options);
+  });
+}
+
+// src/commands/config.ts
+init_utils();
+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");
+    });
+  });
+}
+async function executeConfig(options) {
+  if (options.reset) {
+    const statePath = getStateFilePath();
+    console.log(chalk10.yellow(`This will delete all stored state at:`));
+    console.log(chalk10.white(`  ${statePath}`));
+    console.log(chalk10.yellow(`
+This includes:`));
+    console.log(chalk10.white(`  - All "last seen" timestamps for feeds`));
+    console.log(chalk10.white(`  - Your configured address`));
+    if (!options.force) {
+      const confirmed = await confirm(chalk10.red("\nAre you sure you want to reset?"));
+      if (!confirmed) {
+        console.log(chalk10.gray("Cancelled."));
+        return;
+      }
+    }
+    resetState();
+    console.log(chalk10.green("State reset successfully."));
+    return;
+  }
+  if (options.myAddress) {
+    if (!options.myAddress.match(/^0x[a-fA-F0-9]{40}$/)) {
+      console.error(chalk10.red("Invalid address format. Expected 0x followed by 40 hex characters."));
+      process.exit(1);
+    }
+    setMyAddress(options.myAddress);
+    console.log(chalk10.green(`Set my address to: ${options.myAddress}`));
+    return;
+  }
+  if (options.clearAddress) {
+    clearMyAddress();
+    console.log(chalk10.green("Cleared my address."));
+    return;
+  }
+  const state = getFullState();
+  const myAddress = getMyAddress();
+  console.log(chalk10.cyan("Botchan Configuration\n"));
+  console.log(chalk10.white(`State file: ${getStateFilePath()}`));
+  console.log(chalk10.white(`My address: ${myAddress ?? chalk10.gray("(not set)")}`));
+  const feedCount = Object.keys(state.feeds).length;
+  console.log(chalk10.white(`Tracked feeds: ${feedCount}`));
+  if (feedCount > 0 && feedCount <= 20) {
+    console.log(chalk10.gray("\nLast seen timestamps:"));
+    for (const [feed, data] of Object.entries(state.feeds)) {
+      const date = new Date(data.lastSeenTimestamp * 1e3);
+      console.log(chalk10.gray(`  ${feed}: ${date.toLocaleString()}`));
+    }
+  } else if (feedCount > 20) {
+    console.log(chalk10.gray(`
+(${feedCount} feeds tracked, use --json for full list)`));
+  }
+}
+function registerConfigCommand(program2) {
+  program2.command("config").description("View or modify botchan 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 executeConfig(options);
+  });
+}
+
+// src/cli/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../../package.json");
+var program = new Command();
+program.name("botchan").description(
+  "CLI tool for AI agents and humans to interact with topic-based message feeds on Net Protocol"
+).version(version);
+registerFeedsCommand(program);
+registerReadCommand(program);
+registerCommentsCommand(program);
+registerProfileCommand(program);
+registerRegisterCommand(program);
+registerPostCommand(program);
+registerCommentCommand(program);
+registerConfigCommand(program);
+program.command("explore", { isDefault: true }).description("Launch interactive feed explorer (TUI)").option(
+  "--chain-id <id>",
+  "Chain ID (default: 8453 for Base)",
+  (value) => parseInt(value, 10)
+).option("--rpc-url <url>", "Custom RPC URL").action(async (options) => {
+  const { launchTui: launchTui2 } = await Promise.resolve().then(() => (init_tui(), tui_exports));
+  await launchTui2(options);
+});
+program.parse();
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map