@opensea/cli 0.3.0 → 0.4.1

package/README.md

@@ -89,7 +89,7 @@ opensea --format table collections stats mfers
 | `swaps` | Get swap quotes for token trading |
 | `accounts` | Get account details |
 
-Global options: `--api-key`, `--chain` (default: ethereum), `--format` (json/table), `--base-url`
+Global options: `--api-key`, `--chain` (default: ethereum), `--format` (json/table/toon), `--base-url`
 
 Full command reference with all options and flags: [docs/cli-reference.md](docs/cli-reference.md)
 
@@ -137,6 +137,33 @@ Table - human-readable output:
 opensea --format table collections list --limit 5
 ```
 
+TOON - [Token-Oriented Object Notation](https://github.com/toon-format/toon), a compact format that uses ~40% fewer tokens than JSON. Ideal for piping output into LLM / AI agent context windows:
+
+```bash
+opensea --format toon tokens trending --limit 5
+```
+
+Example TOON output for a list of tokens:
+
+```
+tokens[3]{name,symbol,chain,market_cap,price_usd}:
+  Ethereum,ETH,ethereum,250000000000,2100.50
+  Bitcoin,BTC,bitcoin,900000000000,48000.00
+  Solana,SOL,solana,30000000000,95.25
+next: abc123
+```
+
+TOON collapses uniform arrays of objects into CSV-like tables with a single header row, while nested objects use YAML-like indentation. The encoder follows the [TOON v3.0 spec](https://github.com/toon-format/spec/blob/main/SPEC.md) and is implemented without external dependencies.
+
+TOON is also available programmatically via the SDK:
+
+```typescript
+import { formatToon } from "@opensea/cli"
+
+const data = await client.tokens.trending({ limit: 5 })
+console.log(formatToon(data))
+```
+
 ## Exit Codes
 
 - `0` - Success

package/dist/cli.js

@@ -5,19 +5,16 @@ import { Command as Command10 } from "commander";
 
 // src/client.ts
 var DEFAULT_BASE_URL = "https://api.opensea.io";
-var DEFAULT_GRAPHQL_URL = "https://gql.opensea.io/graphql";
 var DEFAULT_TIMEOUT_MS = 3e4;
 var OpenSeaClient = class {
   apiKey;
   baseUrl;
-  graphqlUrl;
   defaultChain;
   timeoutMs;
   verbose;
   constructor(config) {
     this.apiKey = config.apiKey;
     this.baseUrl = config.baseUrl ?? DEFAULT_BASE_URL;
-    this.graphqlUrl = config.graphqlUrl ?? DEFAULT_GRAPHQL_URL;
     this.defaultChain = config.chain ?? "ethereum";
     this.timeoutMs = config.timeout ?? DEFAULT_TIMEOUT_MS;
     this.verbose = config.verbose ?? false;
@@ -85,40 +82,6 @@ var OpenSeaClient = class {
     }
     return response.json();
   }
-  async graphql(query, variables) {
-    if (this.verbose) {
-      console.error(`[verbose] POST ${this.graphqlUrl}`);
-    }
-    const response = await fetch(this.graphqlUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Accept: "application/json",
-        "x-api-key": this.apiKey
-      },
-      body: JSON.stringify({ query, variables }),
-      signal: AbortSignal.timeout(this.timeoutMs)
-    });
-    if (this.verbose) {
-      console.error(`[verbose] ${response.status} ${response.statusText}`);
-    }
-    if (!response.ok) {
-      const body = await response.text();
-      throw new OpenSeaAPIError(response.status, body, "graphql");
-    }
-    const json = await response.json();
-    if (json.errors?.length) {
-      throw new OpenSeaAPIError(
-        400,
-        json.errors.map((e) => e.message).join("; "),
-        "graphql"
-      );
-    }
-    if (!json.data) {
-      throw new OpenSeaAPIError(500, "GraphQL response missing data", "graphql");
-    }
-    return json.data;
-  }
   getDefaultChain() {
     return this.defaultChain;
   }
@@ -136,11 +99,284 @@ var OpenSeaAPIError = class extends Error {
 // src/commands/accounts.ts
 import { Command } from "commander";
 
+// src/toon.ts
+var INDENT = "  ";
+var NUMERIC_RE = /^-?\d+(?:\.\d+)?(?:e[+-]?\d+)?$/i;
+var LEADING_ZERO_RE = /^0\d+$/;
+var UNQUOTED_KEY_RE = /^[A-Za-z_][A-Za-z0-9_.]*$/;
+function escapeString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function needsQuoting(value, delimiter) {
+  if (value === "") return true;
+  if (value !== value.trim()) return true;
+  if (value === "true" || value === "false" || value === "null") return true;
+  if (NUMERIC_RE.test(value) || LEADING_ZERO_RE.test(value)) return true;
+  if (/[:"\\[\]{}]/.test(value)) return true;
+  if (/[\n\r\t]/.test(value)) return true;
+  if (value.includes(delimiter)) return true;
+  if (value.startsWith("-")) return true;
+  return false;
+}
+function encodeKey(key) {
+  if (UNQUOTED_KEY_RE.test(key)) return key;
+  return `"${escapeString(key)}"`;
+}
+function encodePrimitive(value, delimiter) {
+  if (value === null) return "null";
+  if (value === void 0) return "null";
+  if (typeof value === "boolean") return String(value);
+  if (typeof value === "number") return String(value);
+  if (typeof value === "string") {
+    if (needsQuoting(value, delimiter)) {
+      return `"${escapeString(value)}"`;
+    }
+    return value;
+  }
+  return `"${escapeString(String(value))}"`;
+}
+function isPrimitive(value) {
+  return value === null || value === void 0 || typeof value === "boolean" || typeof value === "number" || typeof value === "string";
+}
+function isTabular(arr) {
+  if (arr.length === 0) return false;
+  const first = arr[0];
+  if (first === null || typeof first !== "object" || Array.isArray(first))
+    return false;
+  const keys = Object.keys(first).sort();
+  for (const item of arr) {
+    if (item === null || typeof item !== "object" || Array.isArray(item))
+      return false;
+    const itemKeys = Object.keys(item).sort();
+    if (itemKeys.length !== keys.length) return false;
+    for (let i = 0; i < keys.length; i++) {
+      if (itemKeys[i] !== keys[i]) return false;
+    }
+    for (const k of keys) {
+      if (!isPrimitive(item[k])) return false;
+    }
+  }
+  return true;
+}
+function isPrimitiveArray(arr) {
+  return arr.every(isPrimitive);
+}
+function encodeValue(value, depth, delimiter) {
+  if (isPrimitive(value)) {
+    return encodePrimitive(value, delimiter);
+  }
+  if (Array.isArray(value)) {
+    return encodeArray(value, depth, delimiter);
+  }
+  if (typeof value === "object" && value !== null) {
+    return encodeObject(value, depth, delimiter);
+  }
+  return encodePrimitive(value, delimiter);
+}
+function encodeObject(obj, depth, delimiter) {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return "";
+  const lines = [];
+  const prefix = INDENT.repeat(depth);
+  for (const [key, value] of entries) {
+    const encodedKey = encodeKey(key);
+    if (isPrimitive(value)) {
+      lines.push(`${prefix}${encodedKey}: ${encodePrimitive(value, delimiter)}`);
+    } else if (Array.isArray(value)) {
+      lines.push(encodeArrayField(encodedKey, value, depth, delimiter));
+    } else if (typeof value === "object" && value !== null) {
+      const nested = value;
+      if (Object.keys(nested).length === 0) {
+        lines.push(`${prefix}${encodedKey}:`);
+      } else {
+        lines.push(`${prefix}${encodedKey}:`);
+        lines.push(encodeObject(nested, depth + 1, delimiter));
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function encodeArrayField(encodedKey, arr, depth, delimiter) {
+  const prefix = INDENT.repeat(depth);
+  if (arr.length === 0) {
+    return `${prefix}${encodedKey}[0]:`;
+  }
+  if (isPrimitiveArray(arr)) {
+    const values = arr.map((v) => encodePrimitive(v, delimiter)).join(delimiter);
+    return `${prefix}${encodedKey}[${arr.length}]: ${values}`;
+  }
+  if (isTabular(arr)) {
+    const firstObj = arr[0];
+    const fields = Object.keys(firstObj);
+    const fieldHeader = fields.map(encodeKey).join(delimiter);
+    const lines = [];
+    lines.push(`${prefix}${encodedKey}[${arr.length}]{${fieldHeader}}:`);
+    const rowPrefix = INDENT.repeat(depth + 1);
+    for (const item of arr) {
+      const obj = item;
+      const row = fields.map((f) => encodePrimitive(obj[f], delimiter)).join(delimiter);
+      lines.push(`${rowPrefix}${row}`);
+    }
+    return lines.join("\n");
+  }
+  return encodeExpandedList(encodedKey, arr, depth, delimiter);
+}
+function encodeExpandedList(encodedKey, arr, depth, delimiter) {
+  const prefix = INDENT.repeat(depth);
+  const itemPrefix = INDENT.repeat(depth + 1);
+  const lines = [];
+  lines.push(`${prefix}${encodedKey}[${arr.length}]:`);
+  for (const item of arr) {
+    if (isPrimitive(item)) {
+      lines.push(`${itemPrefix}- ${encodePrimitive(item, delimiter)}`);
+    } else if (Array.isArray(item)) {
+      if (isPrimitiveArray(item)) {
+        const values = item.map((v) => encodePrimitive(v, delimiter)).join(delimiter);
+        lines.push(`${itemPrefix}- [${item.length}]: ${values}`);
+      } else {
+        lines.push(`${itemPrefix}- [${item.length}]:`);
+        for (const inner of item) {
+          lines.push(encodeValue(inner, depth + 2, delimiter));
+        }
+      }
+    } else if (typeof item === "object" && item !== null) {
+      const obj = item;
+      const entries = Object.entries(obj);
+      if (entries.length === 0) {
+        lines.push(`${itemPrefix}-`);
+      } else {
+        const [firstKey, firstValue] = entries[0];
+        const ek = encodeKey(firstKey);
+        if (Array.isArray(firstValue)) {
+          const arrayLine = encodeArrayField(ek, firstValue, 0, delimiter);
+          lines.push(`${itemPrefix}- ${arrayLine.trimStart()}`);
+        } else if (isPrimitive(firstValue)) {
+          lines.push(
+            `${itemPrefix}- ${ek}: ${encodePrimitive(firstValue, delimiter)}`
+          );
+        } else {
+          lines.push(`${itemPrefix}- ${ek}:`);
+          lines.push(
+            encodeObject(
+              firstValue,
+              depth + 2,
+              delimiter
+            )
+          );
+        }
+        for (let i = 1; i < entries.length; i++) {
+          const [k, v] = entries[i];
+          const encodedK = encodeKey(k);
+          if (isPrimitive(v)) {
+            lines.push(
+              `${INDENT.repeat(depth + 2)}${encodedK}: ${encodePrimitive(v, delimiter)}`
+            );
+          } else if (Array.isArray(v)) {
+            lines.push(encodeArrayField(encodedK, v, depth + 2, delimiter));
+          } else if (typeof v === "object" && v !== null) {
+            lines.push(`${INDENT.repeat(depth + 2)}${encodedK}:`);
+            lines.push(
+              encodeObject(v, depth + 3, delimiter)
+            );
+          }
+        }
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function encodeArray(arr, depth, delimiter) {
+  const prefix = INDENT.repeat(depth);
+  if (arr.length === 0) {
+    return `${prefix}[0]:`;
+  }
+  if (isPrimitiveArray(arr)) {
+    const values = arr.map((v) => encodePrimitive(v, delimiter)).join(delimiter);
+    return `${prefix}[${arr.length}]: ${values}`;
+  }
+  if (isTabular(arr)) {
+    const firstObj = arr[0];
+    const fields = Object.keys(firstObj);
+    const fieldHeader = fields.map(encodeKey).join(delimiter);
+    const lines2 = [];
+    lines2.push(`${prefix}[${arr.length}]{${fieldHeader}}:`);
+    const rowPrefix = INDENT.repeat(depth + 1);
+    for (const item of arr) {
+      const obj = item;
+      const row = fields.map((f) => encodePrimitive(obj[f], delimiter)).join(delimiter);
+      lines2.push(`${rowPrefix}${row}`);
+    }
+    return lines2.join("\n");
+  }
+  const lines = [];
+  lines.push(`${prefix}[${arr.length}]:`);
+  const itemPrefix = INDENT.repeat(depth + 1);
+  for (const item of arr) {
+    if (isPrimitive(item)) {
+      lines.push(`${itemPrefix}- ${encodePrimitive(item, delimiter)}`);
+    } else if (Array.isArray(item)) {
+      if (isPrimitiveArray(item)) {
+        const values = item.map((v) => encodePrimitive(v, delimiter)).join(delimiter);
+        lines.push(`${itemPrefix}- [${item.length}]: ${values}`);
+      } else {
+        lines.push(`${itemPrefix}- [${item.length}]:`);
+      }
+    } else if (typeof item === "object" && item !== null) {
+      const obj = item;
+      const entries = Object.entries(obj);
+      if (entries.length > 0) {
+        const [firstKey, firstValue] = entries[0];
+        const ek = encodeKey(firstKey);
+        if (isPrimitive(firstValue)) {
+          lines.push(
+            `${itemPrefix}- ${ek}: ${encodePrimitive(firstValue, delimiter)}`
+          );
+        } else {
+          lines.push(`${itemPrefix}- ${ek}:`);
+          lines.push(encodeValue(firstValue, depth + 2, delimiter));
+        }
+        for (let i = 1; i < entries.length; i++) {
+          const [k, v] = entries[i];
+          const encodedK = encodeKey(k);
+          if (isPrimitive(v)) {
+            lines.push(
+              `${INDENT.repeat(depth + 2)}${encodedK}: ${encodePrimitive(v, delimiter)}`
+            );
+          } else if (Array.isArray(v)) {
+            lines.push(encodeArrayField(encodedK, v, depth + 2, delimiter));
+          } else if (typeof v === "object" && v !== null) {
+            lines.push(`${INDENT.repeat(depth + 2)}${encodedK}:`);
+            lines.push(
+              encodeObject(v, depth + 3, delimiter)
+            );
+          }
+        }
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function formatToon(data) {
+  if (isPrimitive(data)) {
+    return encodePrimitive(data, ",");
+  }
+  if (Array.isArray(data)) {
+    return encodeArray(data, 0, ",");
+  }
+  if (typeof data === "object" && data !== null) {
+    return encodeObject(data, 0, ",");
+  }
+  return String(data);
+}
+
 // src/output.ts
 function formatOutput(data, format) {
   if (format === "table") {
     return formatTable(data);
   }
+  if (format === "toon") {
+    return formatToon(data);
+  }
   return JSON.stringify(data, null, 2);
 }
 function formatTable(data) {
@@ -465,147 +701,30 @@ function offersCommand(getClient2, getFormat2) {
 
 // src/commands/search.ts
 import { Command as Command7 } from "commander";
-
-// src/queries.ts
-var SEARCH_COLLECTIONS_QUERY = `
-query SearchCollections($query: String!, $limit: Int, $chains: [ChainIdentifier!]) {
-  collectionsByQuery(query: $query, limit: $limit, chains: $chains) {
-    slug
-    name
-    description
-    imageUrl
-    chain {
-      identifier
-      name
-    }
-    stats {
-      totalSupply
-      ownerCount
-      volume {
-        usd
-      }
-      sales
-    }
-    floorPrice {
-      pricePerItem {
-        usd
-        native {
-          unit
-          symbol
-        }
-      }
-    }
-  }
-}`;
-var SEARCH_NFTS_QUERY = `
-query SearchItems($query: String!, $collectionSlug: String, $limit: Int, $chains: [ChainIdentifier!]) {
-  itemsByQuery(query: $query, collectionSlug: $collectionSlug, limit: $limit, chains: $chains) {
-    tokenId
-    name
-    description
-    imageUrl
-    contractAddress
-    collection {
-      slug
-      name
-    }
-    chain {
-      identifier
-      name
-    }
-    bestListing {
-      pricePerItem {
-        usd
-        native {
-          unit
-          symbol
-        }
-      }
-    }
-    owner {
-      address
-      displayName
-    }
-  }
-}`;
-var SEARCH_TOKENS_QUERY = `
-query SearchCurrencies($query: String!, $limit: Int, $chain: ChainIdentifier) {
-  currenciesByQuery(query: $query, limit: $limit, chain: $chain, allowlistOnly: false) {
-    name
-    symbol
-    imageUrl
-    usdPrice
-    contractAddress
-    chain {
-      identifier
-      name
-    }
-    stats {
-      marketCapUsd
-      oneDay {
-        priceChange
-        volume
-      }
-    }
-  }
-}`;
-var SEARCH_ACCOUNTS_QUERY = `
-query SearchAccounts($query: String!, $limit: Int) {
-  accountsByQuery(query: $query, limit: $limit) {
-    address
-    username
-    imageUrl
-    isVerified
-  }
-}`;
-
-// src/commands/search.ts
 function searchCommand(getClient2, getFormat2) {
-  const cmd = new Command7("search").description(
-    "Search for collections, NFTs, tokens, and accounts"
-  );
-  cmd.command("collections").description("Search collections by name or slug").argument("<query>", "Search query").option("--chains <chains>", "Filter by chains (comma-separated)").option("--limit <limit>", "Number of results", "10").action(
-    async (query, options) => {
-      const client = getClient2();
-      const result = await client.graphql(SEARCH_COLLECTIONS_QUERY, {
-        query,
-        limit: parseIntOption(options.limit, "--limit"),
-        chains: options.chains?.split(",")
-      });
-      console.log(formatOutput(result.collectionsByQuery, getFormat2()));
-    }
-  );
-  cmd.command("nfts").description("Search NFTs by name").argument("<query>", "Search query").option("--collection <slug>", "Filter by collection slug").option("--chains <chains>", "Filter by chains (comma-separated)").option("--limit <limit>", "Number of results", "10").action(
+  const cmd = new Command7("search").description("Search across collections, tokens, NFTs, and accounts").argument("<query>", "Search query").option(
+    "--types <types>",
+    "Filter by type (comma-separated: collection,nft,token,account)"
+  ).option("--chains <chains>", "Filter by chains (comma-separated)").option("--limit <limit>", "Number of results", "20").action(
     async (query, options) => {
       const client = getClient2();
-      const result = await client.graphql(SEARCH_NFTS_QUERY, {
+      const params = {
         query,
-        collectionSlug: options.collection,
-        limit: parseIntOption(options.limit, "--limit"),
-        chains: options.chains?.split(",")
-      });
-      console.log(formatOutput(result.itemsByQuery, getFormat2()));
-    }
-  );
-  cmd.command("tokens").description("Search tokens/currencies by name or symbol").argument("<query>", "Search query").option("--chain <chain>", "Filter by chain").option("--limit <limit>", "Number of results", "10").action(
-    async (query, options) => {
-      const client = getClient2();
-      const result = await client.graphql(SEARCH_TOKENS_QUERY, {
-        query,
-        limit: parseIntOption(options.limit, "--limit"),
-        chain: options.chain
-      });
-      console.log(formatOutput(result.currenciesByQuery, getFormat2()));
+        limit: parseIntOption(options.limit, "--limit")
+      };
+      if (options.types) {
+        params.asset_types = options.types;
+      }
+      if (options.chains) {
+        params.chains = options.chains;
+      }
+      const result = await client.get(
+        "/api/v2/search",
+        params
+      );
+      console.log(formatOutput(result, getFormat2()));
     }
   );
-  cmd.command("accounts").description("Search accounts by username or address").argument("<query>", "Search query").option("--limit <limit>", "Number of results", "10").action(async (query, options) => {
-    const client = getClient2();
-    const result = await client.graphql(SEARCH_ACCOUNTS_QUERY, {
-      query,
-      limit: parseIntOption(options.limit, "--limit")
-    });
-    console.log(formatOutput(result.accountsByQuery, getFormat2()));
-  });
   return cmd;
 }
 
@@ -709,7 +828,7 @@ var BANNER = `
         |_|
 `;
 var program = new Command10();
-program.name("opensea").description("OpenSea CLI - Query the OpenSea API from the command line").version(process.env.npm_package_version ?? "0.0.0").addHelpText("before", BANNER).option("--api-key <key>", "OpenSea API key (or set OPENSEA_API_KEY env var)").option("--chain <chain>", "Default chain", "ethereum").option("--format <format>", "Output format (json or table)", "json").option("--base-url <url>", "API base URL").option("--timeout <ms>", "Request timeout in milliseconds", "30000").option("--verbose", "Log request and response info to stderr");
+program.name("opensea").description("OpenSea CLI - Query the OpenSea API from the command line").version(process.env.npm_package_version ?? "0.0.0").addHelpText("before", BANNER).option("--api-key <key>", "OpenSea API key (or set OPENSEA_API_KEY env var)").option("--chain <chain>", "Default chain", "ethereum").option("--format <format>", "Output format (json, table, or toon)", "json").option("--base-url <url>", "API base URL").option("--timeout <ms>", "Request timeout in milliseconds", "30000").option("--verbose", "Log request and response info to stderr");
 function getClient() {
   const opts = program.opts();
   const apiKey = opts.apiKey ?? process.env.OPENSEA_API_KEY;
@@ -729,7 +848,9 @@ function getClient() {
 }
 function getFormat() {
   const opts = program.opts();
-  return opts.format === "table" ? "table" : "json";
+  if (opts.format === "table") return "table";
+  if (opts.format === "toon") return "toon";
+  return "json";
 }
 program.addCommand(collectionsCommand(getClient, getFormat));
 program.addCommand(nftsCommand(getClient, getFormat));