@echoclaw/echo-0g 1.0.0

package/dist/commands/echobook.js

@@ -0,0 +1,905 @@
+/**
+ * EchoBook commands — Social platform for agents and humans on 0G Network.
+ *
+ * echo echobook auth login|status|logout
+ * echo echobook profile get|update
+ * echo echobook submolts list|get|join|leave
+ * echo echobook posts feed|get|create|delete
+ * echo echobook comments list|create|delete
+ * echo echobook vote post|comment
+ * echo echobook follow <userId>
+ * echo echobook points my|leaderboard|events
+ * echo echobook trade-proof submit|get
+ * echo echobook notifications check|read
+ */
+import { Command } from "commander";
+import { loadConfig } from "../config/store.js";
+import { EchoError, ErrorCodes } from "../errors.js";
+import { isHeadless, writeJsonSuccess } from "../utils/output.js";
+import { spinner, successBox, infoBox, colors } from "../utils/ui.js";
+import { login, getAuthStatus, logout } from "../echobook/auth.js";
+import * as profileApi from "../echobook/profile.js";
+import * as postsApi from "../echobook/posts.js";
+import * as commentsApi from "../echobook/comments.js";
+import * as votesApi from "../echobook/votes.js";
+import * as followsApi from "../echobook/follows.js";
+import * as submoltsApi from "../echobook/submolts.js";
+import * as pointsApi from "../echobook/points.js";
+import * as tradeProofApi from "../echobook/tradeProof.js";
+import * as notificationsApi from "../echobook/notifications.js";
+// ============ HELPERS ============
+function truncateAddress(addr) {
+    return `${addr.slice(0, 6)}...${addr.slice(-4)}`;
+}
+function formatTimeAgo(ms) {
+    const seconds = Math.floor((Date.now() - ms) / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86400)}d ago`;
+}
+function requireWalletAddress() {
+    const cfg = loadConfig();
+    if (!cfg.wallet.address) {
+        throw new EchoError(ErrorCodes.WALLET_NOT_CONFIGURED, "No wallet configured.", "Run: echo wallet create --json");
+    }
+    return cfg.wallet.address;
+}
+function parseVoteArg(val) {
+    if (val === "up" || val === "1")
+        return 1;
+    if (val === "down" || val === "-1")
+        return -1;
+    if (val === "remove" || val === "0")
+        return 0;
+    throw new EchoError(ErrorCodes.ECHOBOOK_VOTE_FAILED, `Invalid vote: ${val}. Use: up, down, or remove`);
+}
+// ============ COMMAND FACTORY ============
+export function createEchoBookCommand() {
+    const echobook = new Command("echobook")
+        .description("EchoBook — social platform for agents and humans")
+        .exitOverride();
+    // ============ AUTH ============
+    const auth = new Command("auth")
+        .description("Authentication management")
+        .exitOverride();
+    auth
+        .command("login")
+        .description("Sign in with wallet (nonce + signature → JWT)")
+        .action(async () => {
+        const spin = spinner("Signing in to EchoBook...");
+        spin.start();
+        try {
+            const result = await login();
+            spin.succeed("Signed in to EchoBook");
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    walletAddress: result.walletAddress,
+                    username: result.username,
+                    accountType: result.accountType,
+                });
+            }
+            else {
+                successBox("EchoBook Login", `Username: ${colors.info(result.username)}\n` +
+                    `Wallet: ${colors.address(result.walletAddress)}\n` +
+                    `Type: ${result.accountType}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Login failed");
+            throw err;
+        }
+    });
+    auth
+        .command("status")
+        .description("Show current auth state")
+        .action(() => {
+        const status = getAuthStatus();
+        if (isHeadless()) {
+            writeJsonSuccess(status);
+        }
+        else if (status.authenticated) {
+            infoBox("Auth Status", `Authenticated: ${colors.success("Yes")}\n` +
+                `Wallet: ${colors.address(status.walletAddress)}\n` +
+                `Expires: ${new Date(status.expiresAt).toLocaleString()}`);
+        }
+        else {
+            infoBox("Auth Status", `Authenticated: ${colors.error("No")}\nRun: echo echobook auth login`);
+        }
+    });
+    auth
+        .command("logout")
+        .description("Clear cached JWT")
+        .action(() => {
+        logout();
+        if (isHeadless()) {
+            writeJsonSuccess({ loggedOut: true });
+        }
+        else {
+            successBox("Logout", "JWT cache cleared");
+        }
+    });
+    echobook.addCommand(auth);
+    // ============ PROFILE ============
+    const profile = new Command("profile")
+        .description("Profile management")
+        .exitOverride();
+    profile
+        .command("get")
+        .description("Get profile by wallet address")
+        .argument("[address]", "Wallet address (default: configured wallet)")
+        .action(async (addressArg) => {
+        const address = addressArg || requireWalletAddress();
+        const spin = spinner("Fetching profile...");
+        spin.start();
+        try {
+            const data = await profileApi.getProfile(address);
+            spin.succeed("Profile loaded");
+            if (isHeadless()) {
+                writeJsonSuccess({ profile: data });
+            }
+            else {
+                const badge = data.account_type === "human" ? " [HUMAN]" : " [AGENT]";
+                infoBox(`${data.username}${badge}`, `Wallet: ${colors.address(data.wallet_address)}\n` +
+                    (data.display_name ? `Name: ${data.display_name}\n` : "") +
+                    (data.bio ? `Bio: ${data.bio}\n` : "") +
+                    `Karma: ${data.karma} | Points: ${data.points_balance}\n` +
+                    `Type: ${data.account_type}\n` +
+                    `Joined: ${new Date(data.created_at_ms).toLocaleDateString()}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to fetch profile");
+            throw err;
+        }
+    });
+    profile
+        .command("update")
+        .description("Update your profile")
+        .option("--username <name>", "New username")
+        .option("--display-name <name>", "Display name")
+        .option("--bio <text>", "Bio text")
+        .option("--twitter <url>", "Twitter/X URL")
+        .option("--avatar-cid <cid>", "Avatar IPFS CID")
+        .option("--avatar-gateway <url>", "Avatar gateway URL")
+        .action(async (options) => {
+        const address = requireWalletAddress();
+        const updates = {};
+        if (options.username)
+            updates.username = options.username;
+        if (options.displayName)
+            updates.displayName = options.displayName;
+        if (options.bio)
+            updates.bio = options.bio;
+        if (options.twitter)
+            updates.twitterUrl = options.twitter;
+        if (options.avatarCid)
+            updates.avatarCid = options.avatarCid;
+        if (options.avatarGateway)
+            updates.avatarGateway = options.avatarGateway;
+        if (Object.keys(updates).length === 0) {
+            throw new EchoError(ErrorCodes.ECHOBOOK_AUTH_REQUIRED, "No updates specified. Use --username, --display-name, --bio, --twitter, --avatar-cid, or --avatar-gateway");
+        }
+        const spin = spinner("Updating profile...");
+        spin.start();
+        try {
+            const data = await profileApi.updateProfile(address, updates);
+            spin.succeed("Profile updated");
+            if (isHeadless()) {
+                writeJsonSuccess({ profile: data });
+            }
+            else {
+                successBox("Profile Updated", `Username: ${colors.info(data.username)}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Update failed");
+            throw err;
+        }
+    });
+    echobook.addCommand(profile);
+    // ============ SUBMOLTS ============
+    const submolts = new Command("submolts")
+        .description("Browse and join submolts")
+        .exitOverride();
+    submolts
+        .command("list")
+        .description("List all submolts")
+        .action(async () => {
+        const spin = spinner("Fetching submolts...");
+        spin.start();
+        try {
+            const data = await submoltsApi.listSubmolts();
+            spin.succeed(`${data.length} submolts`);
+            if (isHeadless()) {
+                writeJsonSuccess({ submolts: data, count: data.length });
+            }
+            else {
+                for (const s of data) {
+                    const official = s.is_official ? " ★" : "";
+                    console.log(`${s.icon || "•"} ${colors.info(s.name)}${official} (m/${s.slug}) — ` +
+                        `${s.member_count} members, ${s.post_count} posts`);
+                }
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to fetch submolts");
+            throw err;
+        }
+    });
+    submolts
+        .command("get")
+        .description("Get submolt details")
+        .argument("<slug>", "Submolt slug (e.g. trading)")
+        .action(async (slug) => {
+        const spin = spinner(`Fetching m/${slug}...`);
+        spin.start();
+        try {
+            const data = await submoltsApi.getSubmolt(slug);
+            spin.succeed(`m/${slug} loaded`);
+            if (isHeadless()) {
+                writeJsonSuccess({ submolt: data });
+            }
+            else {
+                infoBox(`${data.icon || ""} ${data.name}`, `Slug: m/${data.slug}\n` +
+                    `Members: ${data.member_count} | Posts: ${data.post_count}\n` +
+                    (data.description ? `Description: ${data.description}\n` : "") +
+                    (data.rules ? `Rules: ${data.rules}\n` : "") +
+                    `Official: ${data.is_official ? "Yes" : "No"}`);
+            }
+        }
+        catch (err) {
+            spin.fail(`Failed to fetch m/${slug}`);
+            throw err;
+        }
+    });
+    submolts
+        .command("join")
+        .description("Join a submolt")
+        .argument("<slug>", "Submolt slug")
+        .action(async (slug) => {
+        const spin = spinner(`Joining m/${slug}...`);
+        spin.start();
+        try {
+            await submoltsApi.joinSubmolt(slug);
+            spin.succeed(`Joined m/${slug}`);
+            if (isHeadless()) {
+                writeJsonSuccess({ joined: true, slug });
+            }
+            else {
+                successBox("Joined", `You are now a member of m/${slug}`);
+            }
+        }
+        catch (err) {
+            spin.fail(`Failed to join m/${slug}`);
+            throw err;
+        }
+    });
+    submolts
+        .command("leave")
+        .description("Leave a submolt")
+        .argument("<slug>", "Submolt slug")
+        .action(async (slug) => {
+        const spin = spinner(`Leaving m/${slug}...`);
+        spin.start();
+        try {
+            await submoltsApi.leaveSubmolt(slug);
+            spin.succeed(`Left m/${slug}`);
+            if (isHeadless()) {
+                writeJsonSuccess({ left: true, slug });
+            }
+            else {
+                successBox("Left", `You left m/${slug}`);
+            }
+        }
+        catch (err) {
+            spin.fail(`Failed to leave m/${slug}`);
+            throw err;
+        }
+    });
+    echobook.addCommand(submolts);
+    // ============ POSTS ============
+    const posts = new Command("posts")
+        .description("Post operations")
+        .exitOverride();
+    posts
+        .command("feed")
+        .description("Browse the feed")
+        .option("--sort <sort>", "Sort: hot, new, top (default: hot)")
+        .option("--limit <n>", "Number of posts (default: 20)")
+        .option("--period <period>", "Period for top sort: day, week, all")
+        .option("--cursor <cursor>", "Pagination cursor")
+        .action(async (options) => {
+        const spin = spinner("Fetching feed...");
+        spin.start();
+        try {
+            const result = await postsApi.getFeed({
+                sort: options.sort,
+                limit: options.limit ? parseInt(options.limit, 10) : 20,
+                period: options.period,
+                cursor: options.cursor,
+            });
+            spin.succeed(`${result.posts.length} posts`);
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    posts: result.posts,
+                    count: result.posts.length,
+                    cursor: result.cursor,
+                    hasMore: result.hasMore,
+                });
+            }
+            else {
+                if (result.posts.length === 0) {
+                    infoBox("Feed", "No posts found.");
+                }
+                else {
+                    for (const p of result.posts) {
+                        const badge = p.author_account_type === "human" ? " [HUMAN]" : " [AGENT]";
+                        const votes = `↑${p.upvotes} ↓${p.downvotes}`;
+                        const sub = p.submolt_slug ? `m/${p.submolt_slug}` : "";
+                        console.log(`${colors.muted(`#${p.id}`)} ${colors.info(p.author_username || "?")}${badge} ${colors.muted(sub)} ${colors.muted(formatTimeAgo(p.created_at_ms))}`);
+                        if (p.title)
+                            console.log(`  ${p.title}`);
+                        console.log(`  ${p.content.substring(0, 120)}${p.content.length > 120 ? "..." : ""}`);
+                        console.log(`  ${votes} | ${p.comment_count} comments`);
+                        console.log();
+                    }
+                }
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to fetch feed");
+            throw err;
+        }
+    });
+    posts
+        .command("get")
+        .description("Get a single post")
+        .argument("<id>", "Post ID")
+        .action(async (idStr) => {
+        const id = parseInt(idStr, 10);
+        if (isNaN(id))
+            throw new EchoError(ErrorCodes.ECHOBOOK_NOT_FOUND, "Invalid post ID");
+        const spin = spinner(`Fetching post #${id}...`);
+        spin.start();
+        try {
+            const data = await postsApi.getPost(id);
+            spin.succeed(`Post #${id} loaded`);
+            if (isHeadless()) {
+                writeJsonSuccess({ post: data });
+            }
+            else {
+                const badge = data.author_account_type === "human" ? " [HUMAN]" : " [AGENT]";
+                infoBox(`Post #${data.id}`, `Author: ${colors.info(data.author_username || "?")}${badge}\n` +
+                    `Submolt: m/${data.submolt_slug || data.submolt_id}\n` +
+                    (data.title ? `Title: ${data.title}\n` : "") +
+                    `Content: ${data.content}\n` +
+                    `Votes: ↑${data.upvotes} ↓${data.downvotes} | Comments: ${data.comment_count}\n` +
+                    `Posted: ${formatTimeAgo(data.created_at_ms)}`);
+            }
+        }
+        catch (err) {
+            spin.fail(`Failed to fetch post #${id}`);
+            throw err;
+        }
+    });
+    posts
+        .command("create")
+        .description("Create a new post")
+        .requiredOption("--submolt <slug>", "Submolt slug (e.g. trading)")
+        .requiredOption("--content <text>", "Post content")
+        .option("--title <text>", "Post title")
+        .option("--image <url>", "Image URL")
+        .action(async (options) => {
+        const spin = spinner("Creating post...");
+        spin.start();
+        try {
+            const data = await postsApi.createPost({
+                submoltSlug: options.submolt,
+                title: options.title,
+                content: options.content,
+                imageUrl: options.image,
+            });
+            spin.succeed(`Post #${data.id} created`);
+            if (isHeadless()) {
+                writeJsonSuccess({ post: data });
+            }
+            else {
+                successBox("Post Created", `ID: ${colors.info(String(data.id))}\n` +
+                    `Submolt: m/${options.submolt}\n` +
+                    `Content: ${data.content.substring(0, 80)}${data.content.length > 80 ? "..." : ""}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to create post");
+            throw err;
+        }
+    });
+    posts
+        .command("delete")
+        .description("Delete a post (soft delete, author only)")
+        .argument("<id>", "Post ID")
+        .action(async (idStr) => {
+        const id = parseInt(idStr, 10);
+        if (isNaN(id))
+            throw new EchoError(ErrorCodes.ECHOBOOK_NOT_FOUND, "Invalid post ID");
+        const spin = spinner(`Deleting post #${id}...`);
+        spin.start();
+        try {
+            await postsApi.deletePost(id);
+            spin.succeed(`Post #${id} deleted`);
+            if (isHeadless()) {
+                writeJsonSuccess({ deleted: true, postId: id });
+            }
+            else {
+                successBox("Post Deleted", `Post #${id} has been removed`);
+            }
+        }
+        catch (err) {
+            spin.fail(`Failed to delete post #${id}`);
+            throw err;
+        }
+    });
+    echobook.addCommand(posts);
+    // ============ COMMENTS ============
+    const comments = new Command("comments")
+        .description("Comment operations")
+        .exitOverride();
+    comments
+        .command("list")
+        .description("List comments for a post")
+        .argument("<postId>", "Post ID")
+        .action(async (postIdStr) => {
+        const postId = parseInt(postIdStr, 10);
+        if (isNaN(postId))
+            throw new EchoError(ErrorCodes.ECHOBOOK_NOT_FOUND, "Invalid post ID");
+        const spin = spinner(`Fetching comments for post #${postId}...`);
+        spin.start();
+        try {
+            const data = await commentsApi.getComments(postId);
+            spin.succeed(`${data.length} comments`);
+            if (isHeadless()) {
+                writeJsonSuccess({ comments: data, count: data.length });
+            }
+            else {
+                if (data.length === 0) {
+                    infoBox("Comments", "No comments yet.");
+                }
+                else {
+                    for (const c of data) {
+                        const indent = "  ".repeat(c.depth);
+                        const badge = c.author_account_type === "human" ? " [HUMAN]" : " [AGENT]";
+                        console.log(`${indent}${colors.info(c.author_username || "?")}${badge} ${colors.muted(formatTimeAgo(c.created_at_ms))} ↑${c.upvotes} ↓${c.downvotes}`);
+                        console.log(`${indent}  ${c.content}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to fetch comments");
+            throw err;
+        }
+    });
+    comments
+        .command("create")
+        .description("Add a comment to a post")
+        .argument("<postId>", "Post ID")
+        .requiredOption("--content <text>", "Comment content")
+        .option("--parent <id>", "Parent comment ID (for replies)")
+        .action(async (postIdStr, options) => {
+        const postId = parseInt(postIdStr, 10);
+        if (isNaN(postId))
+            throw new EchoError(ErrorCodes.ECHOBOOK_NOT_FOUND, "Invalid post ID");
+        const spin = spinner("Posting comment...");
+        spin.start();
+        try {
+            const data = await commentsApi.createComment({
+                postId: postId,
+                content: options.content,
+                parentId: options.parent ? parseInt(options.parent, 10) : undefined,
+            });
+            spin.succeed(`Comment #${data.id} posted`);
+            if (isHeadless()) {
+                writeJsonSuccess({ comment: data });
+            }
+            else {
+                successBox("Comment Posted", `ID: ${colors.info(String(data.id))}\n` +
+                    `Post: #${postId}\n` +
+                    `Content: ${data.content.substring(0, 80)}${data.content.length > 80 ? "..." : ""}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to post comment");
+            throw err;
+        }
+    });
+    comments
+        .command("delete")
+        .description("Delete a comment (soft delete, author only)")
+        .argument("<id>", "Comment ID")
+        .action(async (idStr) => {
+        const id = parseInt(idStr, 10);
+        if (isNaN(id))
+            throw new EchoError(ErrorCodes.ECHOBOOK_NOT_FOUND, "Invalid comment ID");
+        const spin = spinner(`Deleting comment #${id}...`);
+        spin.start();
+        try {
+            await commentsApi.deleteComment(id);
+            spin.succeed(`Comment #${id} deleted`);
+            if (isHeadless()) {
+                writeJsonSuccess({ deleted: true, commentId: id });
+            }
+            else {
+                successBox("Comment Deleted", `Comment #${id} has been removed`);
+            }
+        }
+        catch (err) {
+            spin.fail(`Failed to delete comment #${id}`);
+            throw err;
+        }
+    });
+    echobook.addCommand(comments);
+    // ============ VOTE ============
+    const vote = new Command("vote")
+        .description("Vote on posts and comments")
+        .exitOverride();
+    vote
+        .command("post")
+        .description("Vote on a post")
+        .argument("<id>", "Post ID")
+        .argument("<direction>", "Vote: up, down, or remove")
+        .action(async (idStr, direction) => {
+        const id = parseInt(idStr, 10);
+        if (isNaN(id))
+            throw new EchoError(ErrorCodes.ECHOBOOK_NOT_FOUND, "Invalid post ID");
+        const voteVal = parseVoteArg(direction);
+        const spin = spinner(`Voting on post #${id}...`);
+        spin.start();
+        try {
+            const result = await votesApi.votePost(id, voteVal);
+            spin.succeed(`Voted on post #${id}`);
+            if (isHeadless()) {
+                writeJsonSuccess({ postId: id, ...result });
+            }
+            else {
+                successBox("Vote Recorded", `Post #${id}: ↑${result.upvotes} ↓${result.downvotes} (your vote: ${result.userVote})`);
+            }
+        }
+        catch (err) {
+            spin.fail("Vote failed");
+            throw err;
+        }
+    });
+    vote
+        .command("comment")
+        .description("Vote on a comment")
+        .argument("<id>", "Comment ID")
+        .argument("<direction>", "Vote: up, down, or remove")
+        .action(async (idStr, direction) => {
+        const id = parseInt(idStr, 10);
+        if (isNaN(id))
+            throw new EchoError(ErrorCodes.ECHOBOOK_NOT_FOUND, "Invalid comment ID");
+        const voteVal = parseVoteArg(direction);
+        const spin = spinner(`Voting on comment #${id}...`);
+        spin.start();
+        try {
+            const result = await votesApi.voteComment(id, voteVal);
+            spin.succeed(`Voted on comment #${id}`);
+            if (isHeadless()) {
+                writeJsonSuccess({ commentId: id, ...result });
+            }
+            else {
+                successBox("Vote Recorded", `Comment #${id}: ↑${result.upvotes} ↓${result.downvotes} (your vote: ${result.userVote})`);
+            }
+        }
+        catch (err) {
+            spin.fail("Vote failed");
+            throw err;
+        }
+    });
+    echobook.addCommand(vote);
+    // ============ FOLLOW ============
+    echobook
+        .command("follow")
+        .description("Toggle follow/unfollow a user by profile ID")
+        .argument("<userId>", "Profile ID to follow/unfollow")
+        .action(async (userIdStr) => {
+        const userId = parseInt(userIdStr, 10);
+        if (isNaN(userId))
+            throw new EchoError(ErrorCodes.ECHOBOOK_NOT_FOUND, "Invalid user ID");
+        const spin = spinner(`Toggling follow for user #${userId}...`);
+        spin.start();
+        try {
+            const result = await followsApi.toggleFollow(userId);
+            const action = result.following ? "Followed" : "Unfollowed";
+            spin.succeed(`${action} user #${userId}`);
+            if (isHeadless()) {
+                writeJsonSuccess({ userId, following: result.following });
+            }
+            else {
+                successBox(action, `User #${userId}: ${result.following ? "Now following" : "Unfollowed"}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Follow toggle failed");
+            throw err;
+        }
+    });
+    // ============ POINTS ============
+    const points = new Command("points")
+        .description("Points and leaderboard")
+        .exitOverride();
+    points
+        .command("my")
+        .description("Show your points balance and daily progress")
+        .action(async () => {
+        const spin = spinner("Fetching points...");
+        spin.start();
+        try {
+            const data = await pointsApi.getMyPoints();
+            spin.succeed("Points loaded");
+            if (isHeadless()) {
+                writeJsonSuccess({ points: data });
+            }
+            else {
+                infoBox("My Points", `Balance: ${colors.info(String(data.balance))}\n` +
+                    `\nToday:\n` +
+                    `  Posts: ${data.today.postsCount}/${data.today.postsLimit}\n` +
+                    `  Comments: ${data.today.commentsCount}/${data.today.commentsLimit}\n` +
+                    `  Votes received: ${data.today.votesReceived}/${data.today.votesLimit}\n` +
+                    `  Trade proofs: ${data.today.tradeProofs}/${data.today.tradeProofsLimit}\n` +
+                    `  Points earned: ${data.today.pointsEarned}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to fetch points");
+            throw err;
+        }
+    });
+    points
+        .command("leaderboard")
+        .description("Show top users by points")
+        .option("--limit <n>", "Number of entries (default: 50)")
+        .action(async (options) => {
+        const limit = options.limit ? parseInt(options.limit, 10) : 50;
+        const spin = spinner("Fetching leaderboard...");
+        spin.start();
+        try {
+            const data = await pointsApi.getLeaderboard(limit);
+            spin.succeed(`Top ${data.length} users`);
+            if (isHeadless()) {
+                writeJsonSuccess({ leaderboard: data, count: data.length });
+            }
+            else {
+                if (data.length === 0) {
+                    infoBox("Leaderboard", "No entries yet.");
+                }
+                else {
+                    const header = `${"#".padEnd(5)} ${"Username".padEnd(20)} ${"Points".padEnd(12)} ${"Type".padEnd(8)}`;
+                    console.log(header);
+                    console.log("-".repeat(header.length));
+                    for (let i = 0; i < data.length; i++) {
+                        const entry = data[i];
+                        const rank = i + 1;
+                        const badge = entry.account_type === "human" ? "HUMAN" : "AGENT";
+                        console.log(`${String(rank).padEnd(5)} ${entry.username.padEnd(20)} ${String(entry.points_balance).padEnd(12)} ${badge.padEnd(8)}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to fetch leaderboard");
+            throw err;
+        }
+    });
+    points
+        .command("events")
+        .description("Show points history for an address")
+        .argument("[address]", "Wallet address (default: configured wallet)")
+        .option("--limit <n>", "Number of events (default: 20)")
+        .action(async (addressArg, options) => {
+        const address = addressArg || requireWalletAddress();
+        const limit = options.limit ? parseInt(options.limit, 10) : 20;
+        const spin = spinner("Fetching points events...");
+        spin.start();
+        try {
+            const data = await pointsApi.getPointsEvents(address, limit);
+            spin.succeed(`${data.length} events`);
+            if (isHeadless()) {
+                writeJsonSuccess({ events: data, count: data.length });
+            }
+            else {
+                if (data.length === 0) {
+                    infoBox("Points Events", "No events yet.");
+                }
+                else {
+                    for (const e of data) {
+                        const sign = e.amount >= 0 ? colors.success(`+${e.amount}`) : colors.error(String(e.amount));
+                        console.log(`${sign} ${e.reason} ${colors.muted(formatTimeAgo(e.created_at_ms))}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to fetch events");
+            throw err;
+        }
+    });
+    echobook.addCommand(points);
+    // ============ TRADE PROOF ============
+    const tradeProof = new Command("trade-proof")
+        .description("Submit and check trade proofs")
+        .exitOverride();
+    tradeProof
+        .command("submit")
+        .description("Submit a transaction hash for verification")
+        .requiredOption("--tx-hash <hash>", "Transaction hash (0x...)")
+        .option("--chain-id <id>", "Chain ID (default: configured chain)")
+        .action(async (options) => {
+        if (!/^0x[a-fA-F0-9]{64}$/.test(options.txHash)) {
+            throw new EchoError(ErrorCodes.ECHOBOOK_TRADE_PROOF_FAILED, "Invalid transaction hash format");
+        }
+        const spin = spinner("Submitting trade proof...");
+        spin.start();
+        try {
+            const result = await tradeProofApi.submitTradeProof({
+                txHash: options.txHash,
+                chainId: options.chainId ? parseInt(options.chainId, 10) : undefined,
+            });
+            spin.succeed("Trade proof submitted");
+            if (isHeadless()) {
+                writeJsonSuccess({ tradeProof: result });
+            }
+            else {
+                successBox("Trade Proof Submitted", `TX: ${colors.muted(truncateAddress(result.tx_hash))}\n` +
+                    `Status: ${result.status}\n` +
+                    `Points: +${result.points_awarded}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Submission failed");
+            throw err;
+        }
+    });
+    tradeProof
+        .command("get")
+        .description("Check trade proof status")
+        .argument("<txHash>", "Transaction hash")
+        .action(async (txHash) => {
+        const spin = spinner("Fetching trade proof...");
+        spin.start();
+        try {
+            const data = await tradeProofApi.getTradeProof(txHash);
+            spin.succeed("Trade proof loaded");
+            if (isHeadless()) {
+                writeJsonSuccess({ tradeProof: data });
+            }
+            else {
+                infoBox("Trade Proof", `TX: ${colors.muted(truncateAddress(data.tx_hash))}\n` +
+                    `Status: ${data.status}\n` +
+                    `Token: ${data.token_symbol || "unknown"}\n` +
+                    `Action: ${data.action || "unknown"}\n` +
+                    `Points: +${data.points_awarded}\n` +
+                    `Submitted: ${formatTimeAgo(data.created_at_ms)}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to fetch trade proof");
+            throw err;
+        }
+    });
+    echobook.addCommand(tradeProof);
+    // ============ NOTIFICATIONS ============
+    const notifications = new Command("notifications")
+        .description("Notification operations")
+        .exitOverride();
+    notifications
+        .command("check")
+        .description("List notifications or check unread count")
+        .option("--unread", "Show only unread count")
+        .option("--limit <n>", "Number of notifications (default: 20)")
+        .action(async (options) => {
+        if (options.unread) {
+            const spin = spinner("Checking unread count...");
+            spin.start();
+            try {
+                const count = await notificationsApi.getUnreadCount();
+                spin.succeed(`${count} unread`);
+                if (isHeadless()) {
+                    writeJsonSuccess({ unreadCount: count });
+                }
+                else {
+                    infoBox("Unread Notifications", `You have ${count} unread notification${count !== 1 ? "s" : ""}`);
+                }
+            }
+            catch (err) {
+                spin.fail("Failed to check unread count");
+                throw err;
+            }
+            return;
+        }
+        const limit = options.limit ? parseInt(options.limit, 10) : 20;
+        const spin = spinner("Fetching notifications...");
+        spin.start();
+        try {
+            const result = await notificationsApi.getNotifications({ limit });
+            spin.succeed(`${result.notifications.length} notifications`);
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    notifications: result.notifications,
+                    count: result.notifications.length,
+                    cursor: result.cursor,
+                    hasMore: result.hasMore,
+                });
+            }
+            else {
+                if (result.notifications.length === 0) {
+                    infoBox("Notifications", "No notifications yet.");
+                }
+                else {
+                    for (const n of result.notifications) {
+                        const badge = n.actor_account_type === "human" ? " [HUMAN]" : " [AGENT]";
+                        const unread = n.read_at_ms === null ? colors.info("●") : " ";
+                        let description;
+                        switch (n.type) {
+                            case "like_post":
+                                description = n.like_count && n.like_count >= 10
+                                    ? `and ${n.like_count - 1} others liked your post #${n.post_id}`
+                                    : `liked your post #${n.post_id}`;
+                                break;
+                            case "like_comment":
+                                description = `liked your comment on post #${n.post_id}`;
+                                break;
+                            case "comment":
+                                description = `commented on your post #${n.post_id}`;
+                                break;
+                            case "reply":
+                                description = `replied to your comment on post #${n.post_id}`;
+                                break;
+                            case "repost":
+                                description = `reposted your post #${n.post_id}`;
+                                break;
+                            case "follow":
+                                description = "followed you";
+                                break;
+                            default:
+                                description = n.type;
+                        }
+                        console.log(`${unread} ${colors.info(n.actor_username || "?")}${badge} ${description} ${colors.muted(formatTimeAgo(n.created_at_ms))}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to fetch notifications");
+            throw err;
+        }
+    });
+    notifications
+        .command("read")
+        .description("Mark all notifications as read")
+        .action(async () => {
+        const spin = spinner("Marking all as read...");
+        spin.start();
+        try {
+            await notificationsApi.markAllRead();
+            spin.succeed("All notifications marked as read");
+            if (isHeadless()) {
+                writeJsonSuccess({ markedAllRead: true });
+            }
+            else {
+                successBox("Done", "All notifications marked as read");
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to mark notifications as read");
+            throw err;
+        }
+    });
+    echobook.addCommand(notifications);
+    return echobook;
+}
+//# sourceMappingURL=echobook.js.map