@echoclaw/echo-0g 1.0.0

package/dist/commands/slop-app.js

@@ -0,0 +1,708 @@
+/**
+ * slop-app commands - Interact with slop.money production APIs
+ * - Profile registration with Echo badge
+ * - Image upload/generate via proxy
+ * - Chat messaging via Socket.IO
+ */
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { io } from "socket.io-client";
+import { loadConfig } from "../config/store.js";
+import { loadKeystore, decryptPrivateKey } from "../wallet/keystore.js";
+import { requireKeystorePassword } from "../utils/env.js";
+import { EchoError, ErrorCodes } from "../errors.js";
+import { isHeadless, writeJsonSuccess } from "../utils/output.js";
+import { spinner, successBox, infoBox, colors } from "../utils/ui.js";
+import { fetchJson, fetchWithTimeout } from "../utils/http.js";
+import { requireSlopAuth } from "../slop/auth.js";
+// ============ HELPERS ============
+function requireWalletAndKeystore() {
+    const cfg = loadConfig();
+    if (!cfg.wallet.address) {
+        throw new EchoError(ErrorCodes.WALLET_NOT_CONFIGURED, "No wallet configured.", "Run: echo wallet create --json");
+    }
+    const password = requireKeystorePassword();
+    const keystore = loadKeystore();
+    if (!keystore) {
+        throw new EchoError(ErrorCodes.KEYSTORE_NOT_FOUND, "Keystore not found.", "Run: echo wallet create --json");
+    }
+    const privateKey = decryptPrivateKey(keystore, password);
+    return { address: cfg.wallet.address, privateKey };
+}
+// ============ COMMAND FACTORY ============
+export function createSlopAppCommand() {
+    const slopApp = new Command("slop-app")
+        .description("Interact with slop.money production APIs")
+        .exitOverride();
+    // ============ PROFILE SUBCOMMAND ============
+    const profile = new Command("profile")
+        .description("Profile management")
+        .exitOverride();
+    profile
+        .command("nonce")
+        .description("[Deprecated] Nonce endpoint removed — auth uses JWT now")
+        .action(async () => {
+        throw new EchoError(ErrorCodes.SLOP_AUTH_FAILED, "Profile nonce endpoint has been removed. Auth now uses JWT tokens.", "Use 'echo slop-app profile register' which handles auth automatically");
+    });
+    profile
+        .command("register")
+        .description("Register agent profile")
+        .requiredOption("--username <name>", "Username (3-15 chars, alphanumeric + underscore)")
+        .option("--twitter <url>", "X.com URL (https://x.com/username)")
+        .option("--avatar-cid <cid>", "IPFS CID from image upload")
+        .option("--avatar-gateway <url>", "Gateway URL from image upload")
+        .requiredOption("--yes", "Confirm registration")
+        .action(async (options) => {
+        if (!options.yes) {
+            throw new EchoError(ErrorCodes.CONFIRMATION_REQUIRED, "Add --yes to confirm");
+        }
+        // Validate username
+        if (!/^[a-zA-Z0-9_]{3,15}$/.test(options.username)) {
+            throw new EchoError(ErrorCodes.INVALID_USERNAME, "Username must be 3-15 characters, alphanumeric and underscore only");
+        }
+        // Validate Twitter URL if provided
+        if (options.twitter && !/^https:\/\/x\.com\/[A-Za-z0-9_]{1,15}$/.test(options.twitter)) {
+            throw new EchoError(ErrorCodes.INVALID_USERNAME, "Invalid X.com URL format. Must be https://x.com/username");
+        }
+        // Validate avatar flags: both must be provided together
+        if ((options.avatarCid && !options.avatarGateway) || (!options.avatarCid && options.avatarGateway)) {
+            throw new EchoError(ErrorCodes.REGISTRATION_FAILED, "Both --avatar-cid and --avatar-gateway are required together. Use 'echo slop-app image upload' to get both values.");
+        }
+        const { address, privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        const spin = spinner("Registering profile...");
+        spin.start();
+        try {
+            // 1. Authenticate (JWT)
+            spin.text = "Authenticating...";
+            const accessToken = await requireSlopAuth(privateKey, address, cfg.services.backendApiUrl);
+            // 2. Register with isEchoBot=true (Bearer auth)
+            spin.text = "Registering profile...";
+            const registerResponse = await fetchJson(`${cfg.services.backendApiUrl}/profiles/register`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "Authorization": `Bearer ${accessToken}`,
+                },
+                body: JSON.stringify({
+                    username: options.username,
+                    twitterUrl: options.twitter || null,
+                    avatarCid: options.avatarCid || null,
+                    avatarGateway: options.avatarGateway || null,
+                    avatarIpfs: options.avatarCid ? `ipfs://${options.avatarCid}` : null,
+                    isEchoBot: true,
+                }),
+            });
+            if (!registerResponse.success || !registerResponse.data) {
+                throw new EchoError(ErrorCodes.REGISTRATION_FAILED, registerResponse.error || "Registration failed");
+            }
+            spin.succeed("Profile registered");
+            const profileData = registerResponse.data;
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    walletAddress: profileData.walletAddress,
+                    username: profileData.username,
+                    isEchoBot: true,
+                    avatarUrl: profileData.avatarUrl,
+                    twitterUrl: profileData.twitterUrl,
+                    createdAt: profileData.createdAt,
+                });
+            }
+            else {
+                successBox("Profile Registered", `Username: ${colors.info(profileData.username)}\n` +
+                    `Wallet: ${colors.address(profileData.walletAddress)}\n` +
+                    `Badge: ${colors.success("(ECHO)")}\n` +
+                    (profileData.twitterUrl ? `Twitter: ${profileData.twitterUrl}\n` : ""));
+            }
+        }
+        catch (err) {
+            spin.fail("Registration failed");
+            if (err instanceof EchoError)
+                throw err;
+            throw new EchoError(ErrorCodes.REGISTRATION_FAILED, `Registration failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    profile
+        .command("show")
+        .description("Show profile by address")
+        .argument("[address]", "Wallet address (default: configured wallet)")
+        .action(async (addressArg) => {
+        const cfg = loadConfig();
+        let targetAddress;
+        if (addressArg) {
+            targetAddress = addressArg;
+        }
+        else if (cfg.wallet.address) {
+            targetAddress = cfg.wallet.address;
+        }
+        else {
+            throw new EchoError(ErrorCodes.WALLET_NOT_CONFIGURED, "No address specified and no wallet configured", "Provide an address or configure a wallet");
+        }
+        const spin = spinner("Fetching profile...");
+        spin.start();
+        try {
+            const response = await fetchJson(`${cfg.services.backendApiUrl}/profiles/${targetAddress}`);
+            if (!response.success || !response.data) {
+                throw new EchoError(ErrorCodes.PROFILE_NOT_FOUND, response.error || "Profile not found");
+            }
+            spin.succeed("Profile loaded");
+            const profile = response.data;
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    walletAddress: profile.walletAddress,
+                    username: profile.username,
+                    isEchoBot: profile.isEchoBot || false,
+                    avatarUrl: profile.avatarUrl,
+                    twitterUrl: profile.twitterUrl,
+                    createdAt: profile.createdAt,
+                });
+            }
+            else {
+                const badgeStr = profile.isEchoBot ? ` ${colors.success("(ECHO)")}` : "";
+                infoBox(`${profile.username}${badgeStr}`, `Wallet: ${colors.address(profile.walletAddress)}\n` +
+                    (profile.avatarUrl ? `Avatar: ${profile.avatarUrl}\n` : "") +
+                    (profile.twitterUrl ? `Twitter: ${profile.twitterUrl}\n` : "") +
+                    `Created: ${new Date(profile.createdAt).toLocaleString()}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to fetch profile");
+            if (err instanceof EchoError)
+                throw err;
+            throw new EchoError(ErrorCodes.PROFILE_NOT_FOUND, `Profile fetch failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    slopApp.addCommand(profile);
+    // ============ IMAGE SUBCOMMAND ============
+    const image = new Command("image")
+        .description("Image upload and generation")
+        .exitOverride();
+    image
+        .command("upload")
+        .description("Upload image to IPFS via proxy")
+        .requiredOption("--file <path>", "Path to image file")
+        .action(async (options) => {
+        const cfg = loadConfig();
+        // Read file
+        let fileBuffer;
+        let filename;
+        try {
+            fileBuffer = readFileSync(options.file);
+            filename = basename(options.file);
+        }
+        catch (err) {
+            throw new EchoError(ErrorCodes.IMAGE_UPLOAD_FAILED, `Failed to read file: ${options.file}`);
+        }
+        // Check file size (5MB limit)
+        if (fileBuffer.length > 5 * 1024 * 1024) {
+            throw new EchoError(ErrorCodes.IMAGE_TOO_LARGE, "Image too large (max 5MB)");
+        }
+        // Detect mime type
+        const mimeTypes = {
+            jpg: "image/jpeg",
+            jpeg: "image/jpeg",
+            png: "image/png",
+            gif: "image/gif",
+        };
+        const ext = filename.split(".").pop()?.toLowerCase() || "";
+        const mimeType = mimeTypes[ext];
+        if (!mimeType) {
+            throw new EchoError(ErrorCodes.IMAGE_INVALID_FORMAT, "Invalid image format. Allowed: jpg, jpeg, png, gif");
+        }
+        const spin = spinner("Uploading image...");
+        spin.start();
+        try {
+            // Create FormData
+            const formData = new FormData();
+            const blob = new Blob([new Uint8Array(fileBuffer)], { type: mimeType });
+            formData.append("image", blob, filename);
+            const response = await fetchWithTimeout(`${cfg.services.proxyApiUrl}/upload-image`, {
+                method: "POST",
+                body: formData,
+            });
+            const result = (await response.json());
+            if (!result.success) {
+                throw new EchoError(ErrorCodes.IMAGE_UPLOAD_FAILED, result.error || "Upload failed");
+            }
+            spin.succeed("Image uploaded");
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    ipfsHash: result.ipfsHash,
+                    gatewayUrl: result.gatewayUrl,
+                    filename,
+                });
+            }
+            else {
+                successBox("Image Uploaded", `File: ${filename}\n` +
+                    `IPFS Hash: ${colors.info(result.ipfsHash)}\n` +
+                    `Gateway URL: ${colors.muted(result.gatewayUrl)}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Upload failed");
+            if (err instanceof EchoError)
+                throw err;
+            throw new EchoError(ErrorCodes.IMAGE_UPLOAD_FAILED, `Upload failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    image
+        .command("generate")
+        .description("Generate AI image from prompt")
+        .requiredOption("--prompt <text>", "Image generation prompt")
+        .option("--upload", "Upload generated image to IPFS")
+        .action(async (options) => {
+        const cfg = loadConfig();
+        if (options.prompt.length > 1000) {
+            throw new EchoError(ErrorCodes.IMAGE_GENERATION_FAILED, "Prompt too long (max 1000 characters)");
+        }
+        const spin = spinner("Generating image...");
+        spin.start();
+        try {
+            const response = await fetchJson(`${cfg.services.proxyApiUrl}/generate-image`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    prompt: options.prompt,
+                    uploadToIPFS: options.upload || false,
+                }),
+                timeoutMs: 120000, // 2 min for generation
+            });
+            if (!response.success) {
+                throw new EchoError(ErrorCodes.IMAGE_GENERATION_FAILED, response.error || "Generation failed");
+            }
+            spin.succeed("Image generated");
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    imageUrl: response.imageUrl,
+                    ipfsHash: response.ipfsHash || null,
+                    gatewayUrl: response.gatewayUrl || null,
+                });
+            }
+            else {
+                const lines = [`Image URL: ${colors.muted(response.imageUrl || "N/A")}`];
+                if (response.ipfsHash) {
+                    lines.push(`IPFS Hash: ${colors.info(response.ipfsHash)}`);
+                    lines.push(`Gateway: ${colors.muted(response.gatewayUrl || "")}`);
+                }
+                successBox("Image Generated", lines.join("\n"));
+            }
+        }
+        catch (err) {
+            spin.fail("Generation failed");
+            if (err instanceof EchoError)
+                throw err;
+            throw new EchoError(ErrorCodes.IMAGE_GENERATION_FAILED, `Generation failed: ${err instanceof Error ? err.message : err}`);
+        }
+    });
+    slopApp.addCommand(image);
+    // ============ CHAT SUBCOMMAND ============
+    const chat = new Command("chat")
+        .description("Global chat operations")
+        .exitOverride();
+    chat
+        .command("post")
+        .description("Post a message to global chat")
+        .requiredOption("--message <text>", "Message content")
+        .option("--gif <url>", "GIF URL")
+        .action(async (options) => {
+        if (!options.message || !options.message.trim()) {
+            throw new EchoError(ErrorCodes.CHAT_MESSAGE_EMPTY, "Message cannot be empty");
+        }
+        if (options.message.length > 500) {
+            throw new EchoError(ErrorCodes.CHAT_MESSAGE_TOO_LONG, "Message too long (max 500 characters)");
+        }
+        const { address, privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        const spin = spinner("Authenticating...");
+        spin.start();
+        // 1. Get JWT access token
+        const accessToken = await requireSlopAuth(privateKey, address, cfg.services.backendApiUrl);
+        spin.text = "Connecting to chat...";
+        // Socket.IO promise wrapper
+        const postMessage = () => {
+            return new Promise((resolve, reject) => {
+                const socket = io(cfg.services.chatWsUrl, {
+                    transports: ["websocket"],
+                    timeout: 30000,
+                });
+                let authenticated = false;
+                const timeoutHandle = setTimeout(() => {
+                    socket.disconnect();
+                    reject(new EchoError(ErrorCodes.HTTP_TIMEOUT, "Chat connection timed out"));
+                }, 60000);
+                socket.on("connect", () => {
+                    spin.text = "Authenticating with JWT...";
+                    socket.emit("chat:auth", { accessToken });
+                });
+                socket.on("chat:auth_ok", (data) => {
+                    authenticated = true;
+                    spin.text = "Sending message...";
+                    socket.emit("chat:send", {
+                        content: options.message.trim(),
+                        gifUrl: options.gif || null,
+                    });
+                });
+                socket.on("chat:auth_failed", (data) => {
+                    clearTimeout(timeoutHandle);
+                    socket.disconnect();
+                    reject(new EchoError(ErrorCodes.CHAT_NOT_AUTHENTICATED, data.error || "Authentication failed"));
+                });
+                socket.on("chat:new", (msg) => {
+                    // Wait for our own message echo
+                    if (authenticated && msg.senderAddress?.toLowerCase() === address.toLowerCase() && msg.content === options.message.trim()) {
+                        clearTimeout(timeoutHandle);
+                        socket.disconnect();
+                        resolve({ messageId: msg.id, timestamp: msg.timestamp });
+                    }
+                });
+                socket.on("chat:error", (data) => {
+                    clearTimeout(timeoutHandle);
+                    socket.disconnect();
+                    reject(new EchoError(ErrorCodes.CHAT_SEND_FAILED, data.error || "Chat error"));
+                });
+                socket.on("connect_error", (err) => {
+                    clearTimeout(timeoutHandle);
+                    socket.disconnect();
+                    reject(new EchoError(ErrorCodes.HTTP_REQUEST_FAILED, `Connection failed: ${err.message}`));
+                });
+                socket.on("disconnect", (reason) => {
+                    if (!authenticated) {
+                        clearTimeout(timeoutHandle);
+                        reject(new EchoError(ErrorCodes.CHAT_SEND_FAILED, `Disconnected: ${reason}`));
+                    }
+                });
+            });
+        };
+        try {
+            const result = await postMessage();
+            spin.succeed("Message posted");
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    messageId: result.messageId,
+                    timestamp: result.timestamp,
+                    content: options.message.trim(),
+                });
+            }
+            else {
+                successBox("Message Posted", `ID: ${colors.info(result.messageId)}\n` +
+                    `Content: ${options.message.trim().substring(0, 50)}${options.message.length > 50 ? "..." : ""}`);
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to post message");
+            throw err;
+        }
+    });
+    chat
+        .command("read")
+        .description("Read recent chat messages (no auth required)")
+        .option("--limit <n>", "Number of messages (1-250, default: server default 25)")
+        .action(async (options) => {
+        const cfg = loadConfig();
+        // Parse and validate limit
+        let limitNum;
+        if (options.limit) {
+            limitNum = parseInt(options.limit, 10);
+            if (isNaN(limitNum) || limitNum < 1 || limitNum > 250) {
+                throw new EchoError(ErrorCodes.CHAT_SEND_FAILED, "Limit must be 1-250");
+            }
+        }
+        const spin = spinner("Connecting to chat...");
+        spin.start();
+        const readHistory = () => {
+            return new Promise((resolve, reject) => {
+                const query = {};
+                if (limitNum)
+                    query.historyLimit = String(limitNum);
+                const socket = io(cfg.services.chatWsUrl, {
+                    transports: ["websocket"],
+                    timeout: 15000,
+                    query,
+                });
+                const timeoutHandle = setTimeout(() => {
+                    socket.disconnect();
+                    reject(new EchoError(ErrorCodes.HTTP_TIMEOUT, "Chat history request timed out"));
+                }, 15000);
+                socket.on("chat:history", (messages) => {
+                    clearTimeout(timeoutHandle);
+                    socket.disconnect();
+                    resolve(messages);
+                });
+                socket.on("connect_error", (err) => {
+                    clearTimeout(timeoutHandle);
+                    socket.disconnect();
+                    reject(new EchoError(ErrorCodes.HTTP_REQUEST_FAILED, `Connection failed: ${err.message}`));
+                });
+                socket.on("chat:error", (data) => {
+                    clearTimeout(timeoutHandle);
+                    socket.disconnect();
+                    reject(new EchoError(ErrorCodes.CHAT_SEND_FAILED, data.error || "Chat error"));
+                });
+            });
+        };
+        try {
+            const messages = await readHistory();
+            spin.succeed(`Received ${messages.length} messages`);
+            if (isHeadless()) {
+                writeJsonSuccess({
+                    count: messages.length,
+                    messages,
+                });
+            }
+            else {
+                if (messages.length === 0) {
+                    infoBox("Chat", "No messages.");
+                }
+                else {
+                    for (const msg of messages) {
+                        const sender = msg.senderDisplayName || msg.senderAddress || "unknown";
+                        const time = msg.timestamp ? new Date(msg.timestamp).toLocaleTimeString() : "";
+                        const content = String(msg.content || "");
+                        const badge = msg.isAgent ? " [BOT]" : msg.senderIsEchoBot ? " [ECHO]" : "";
+                        console.log(`${colors.muted(time)} ${colors.info(String(sender))}${badge}: ${content}`);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to read chat history");
+            throw err;
+        }
+    });
+    slopApp.addCommand(chat);
+    // ============ AGENTS SUBCOMMAND ============
+    const agents = new Command("agents")
+        .description("Query tokens via Agent DSL")
+        .exitOverride();
+    // --- Helpers ---
+    function normalizeQuery(query) {
+        const normalized = {
+            source: query.source,
+            orderBy: query.orderBy ?? { field: "created_at_ms", direction: "desc" },
+            limit: query.limit ?? 50,
+        };
+        if (query.filters && query.filters.length > 0) {
+            normalized.filters = query.filters;
+        }
+        if (query.offset && query.offset > 0) {
+            normalized.offset = query.offset;
+        }
+        return normalized;
+    }
+    async function executeAgentQuery(query) {
+        const { address, privateKey } = requireWalletAndKeystore();
+        const cfg = loadConfig();
+        const normalized = normalizeQuery(query);
+        // 1. Authenticate (JWT)
+        const accessToken = await requireSlopAuth(privateKey, address, cfg.services.backendApiUrl);
+        // 2. Execute query with Bearer auth
+        const response = await fetchWithTimeout(`${cfg.services.backendApiUrl}/agents/query`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${accessToken}`,
+            },
+            body: JSON.stringify({ query: normalized }),
+        });
+        const body = (await response.json());
+        if (!response.ok) {
+            const status = response.status;
+            if (status === 400) {
+                throw new EchoError(ErrorCodes.AGENT_QUERY_INVALID, body.error || "Invalid query");
+            }
+            if (status === 401) {
+                throw new EchoError(ErrorCodes.SLOP_AUTH_FAILED, body.error || "Authentication failed");
+            }
+            if (status === 403) {
+                throw new EchoError(ErrorCodes.PROFILE_NOT_FOUND, body.error || "Profile required", "Register profile first: echo slop-app profile register --username <name> --yes --json");
+            }
+            if (status === 429) {
+                throw new EchoError(ErrorCodes.AGENT_QUERY_FAILED, "Rate limited, try again later");
+            }
+            if (status === 504) {
+                throw new EchoError(ErrorCodes.AGENT_QUERY_TIMEOUT, "Query too complex, simplify filters");
+            }
+            throw new EchoError(ErrorCodes.AGENT_QUERY_FAILED, body.error || `Query failed (HTTP ${status})`);
+        }
+        if (!body.success) {
+            throw new EchoError(ErrorCodes.AGENT_QUERY_FAILED, body.error || "Query failed");
+        }
+        const tokens = body.data || [];
+        return { tokens, count: tokens.length, cached: body.cached ?? false };
+    }
+    function formatAgentTable(tokens) {
+        if (tokens.length === 0)
+            return "No tokens found.";
+        const header = `${"Symbol".padEnd(12)} ${"Name".padEnd(20)} ${"Price".padEnd(14)} ${"Vol 24h".padEnd(14)} ${"Status".padEnd(10)}`;
+        const sep = "-".repeat(header.length);
+        const rows = tokens.map((t) => {
+            const sym = String(t.symbol ?? "").slice(0, 11).padEnd(12);
+            const name = String(t.name ?? "").slice(0, 19).padEnd(20);
+            const price = t.actual_price != null ? Number(t.actual_price).toFixed(6).padEnd(14) : "N/A".padEnd(14);
+            const vol = t.volume_24h != null ? Number(t.volume_24h).toFixed(2).padEnd(14) : "N/A".padEnd(14);
+            const status = String(t.status ?? "").padEnd(10);
+            return `${sym} ${name} ${price} ${vol} ${status}`;
+        });
+        return [header, sep, ...rows].join("\n");
+    }
+    function collect(val, acc) {
+        acc.push(val);
+        return acc;
+    }
+    // --- Commands ---
+    agents
+        .command("query")
+        .description("Execute agent query with full DSL")
+        .requiredOption("--source <source>", "Data source (tokens)")
+        .option("--filter <json>", "Filter as JSON (repeatable)", collect, [])
+        .option("--order-by <field>", "Order by field")
+        .option("--order-dir <dir>", "Order direction (asc|desc)")
+        .option("--limit <n>", "Result limit (1-200)")
+        .option("--offset <n>", "Result offset")
+        .action(async (options) => {
+        // Parse filters
+        const filters = [];
+        for (const raw of options.filter) {
+            try {
+                const parsed = JSON.parse(raw);
+                if (!parsed.field || !parsed.op) {
+                    throw new Error("Filter must have 'field' and 'op'");
+                }
+                filters.push(parsed);
+            }
+            catch (err) {
+                throw new EchoError(ErrorCodes.AGENT_QUERY_INVALID, `Invalid filter JSON: ${raw}`, 'Expected format: \'{"field":"status","op":"=","value":"active"}\'');
+            }
+        }
+        const query = {
+            source: options.source,
+        };
+        if (filters.length > 0)
+            query.filters = filters;
+        if (options.orderBy) {
+            query.orderBy = {
+                field: options.orderBy,
+                direction: options.orderDir || "desc",
+            };
+        }
+        if (options.limit) {
+            const limit = parseInt(options.limit, 10);
+            if (isNaN(limit) || limit < 1 || limit > 200) {
+                throw new EchoError(ErrorCodes.AGENT_QUERY_INVALID, "Limit must be 1-200");
+            }
+            query.limit = limit;
+        }
+        if (options.offset) {
+            const offset = parseInt(options.offset, 10);
+            if (isNaN(offset) || offset < 0) {
+                throw new EchoError(ErrorCodes.AGENT_QUERY_INVALID, "Offset must be >= 0");
+            }
+            query.offset = offset;
+        }
+        const spin = spinner("Querying agents API...");
+        spin.start();
+        try {
+            const result = await executeAgentQuery(query);
+            spin.succeed(`Query returned ${result.count} tokens`);
+            if (isHeadless()) {
+                writeJsonSuccess({ tokens: result.tokens, count: result.count, cached: result.cached });
+            }
+            else {
+                console.log(formatAgentTable(result.tokens));
+            }
+        }
+        catch (err) {
+            spin.fail("Query failed");
+            throw err;
+        }
+    });
+    agents
+        .command("trending")
+        .description("Top tokens by 24h volume")
+        .option("--limit <n>", "Result limit (default: 20)")
+        .action(async (options) => {
+        const limit = options.limit ? parseInt(options.limit, 10) : 20;
+        const spin = spinner("Fetching trending tokens...");
+        spin.start();
+        try {
+            const result = await executeAgentQuery({
+                source: "tokens",
+                orderBy: { field: "volume_24h", direction: "desc" },
+                limit,
+            });
+            spin.succeed(`Trending: ${result.count} tokens`);
+            if (isHeadless()) {
+                writeJsonSuccess({ tokens: result.tokens, count: result.count, cached: result.cached });
+            }
+            else {
+                console.log(formatAgentTable(result.tokens));
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to fetch trending tokens");
+            throw err;
+        }
+    });
+    agents
+        .command("newest")
+        .description("Newest tokens by creation time")
+        .option("--limit <n>", "Result limit (default: 20)")
+        .action(async (options) => {
+        const limit = options.limit ? parseInt(options.limit, 10) : 20;
+        const spin = spinner("Fetching newest tokens...");
+        spin.start();
+        try {
+            const result = await executeAgentQuery({
+                source: "tokens",
+                orderBy: { field: "created_at_ms", direction: "desc" },
+                limit,
+            });
+            spin.succeed(`Newest: ${result.count} tokens`);
+            if (isHeadless()) {
+                writeJsonSuccess({ tokens: result.tokens, count: result.count, cached: result.cached });
+            }
+            else {
+                console.log(formatAgentTable(result.tokens));
+            }
+        }
+        catch (err) {
+            spin.fail("Failed to fetch newest tokens");
+            throw err;
+        }
+    });
+    agents
+        .command("search")
+        .description("Search tokens by name (ILIKE)")
+        .requiredOption("--name <pattern>", "Name search pattern")
+        .option("--limit <n>", "Result limit (default: 20)")
+        .action(async (options) => {
+        const limit = options.limit ? parseInt(options.limit, 10) : 20;
+        if (options.name.length > 100) {
+            throw new EchoError(ErrorCodes.AGENT_QUERY_INVALID, "Search pattern too long (max 100 characters)");
+        }
+        const spin = spinner(`Searching for "${options.name}"...`);
+        spin.start();
+        try {
+            const result = await executeAgentQuery({
+                source: "tokens",
+                filters: [{ field: "name", op: "like", value: options.name }],
+                limit,
+            });
+            spin.succeed(`Found ${result.count} tokens`);
+            if (isHeadless()) {
+                writeJsonSuccess({ tokens: result.tokens, count: result.count, cached: result.cached });
+            }
+            else {
+                console.log(formatAgentTable(result.tokens));
+            }
+        }
+        catch (err) {
+            spin.fail("Search failed");
+            throw err;
+        }
+    });
+    slopApp.addCommand(agents);
+    return slopApp;
+}
+//# sourceMappingURL=slop-app.js.map