@highlightxyz/cli 0.1.0 → 0.3.0

package/README.md

@@ -1,30 +1,55 @@
-# @highlightxyz/cli
+# Highlight CLI
 
-Official command-line interface for the Highlight API. The `hl` binary is built
-on `@highlightxyz/sdk`, so CLI operations use the same generated public
-contract as TypeScript integrations.
+Use `hl` to manage Highlight from a terminal, script, CI job, or agent. It
+covers collections, deployment, sales, gates, media, tokens, contracts, and
+chain configuration.
+
+The CLI is built on `@highlightxyz/sdk`. It calls the same API and follows the
+same validation rules as the SDK and REST API.
+
+[Read the CLI documentation](https://docs.highlight.xyz/cli/setup/).
 
 ## Install
 
+```sh
+npm install --global @highlightxyz/cli
+```
+
+Or use Bun:
+
 ```sh
 bun add --global @highlightxyz/cli
 ```
 
-Node.js 20 or later is supported.
+The CLI requires Node.js 20 or later.
+
+Verify the installation:
+
+```sh
+hl --version
+hl --help
+```
+
+You can run public commands before signing in:
+
+```sh
+hl chains list --testnet
+```
 
 ## Authenticate
 
-Create an API key in Highlight, then log in:
+Create an API key in Highlight, then save and verify it:
 
 ```sh
 hl auth login
+hl auth status
 ```
 
-For CI and agents, prefer an environment variable:
+For CI and agents, set the key in the process environment:
 
 ```sh
 export HIGHLIGHT_API_KEY="hl_live_..."
-hl auth status
+hl auth status --json
 ```
 
 Named profiles and custom API URLs are supported:
@@ -34,11 +59,11 @@ hl auth login --profile staging --api-url http://localhost:8787
 hl collections list --profile staging
 ```
 
-Saved keys live in `~/.config/highlight/config.json` with mode `0600`.
-`HIGHLIGHT_API_KEY`, `HIGHLIGHT_API_URL`, and `HIGHLIGHT_CONFIG_DIR` override
-saved configuration.
+On macOS and Linux, saved keys live in
+`~/.config/highlight/config.json` with mode `0600`. `HIGHLIGHT_API_KEY`,
+`HIGHLIGHT_API_URL`, and `HIGHLIGHT_CONFIG_DIR` override saved configuration.
 
-## Collections
+## Core commands
 
 ```sh
 hl collections list
@@ -47,75 +72,23 @@ hl collections create --input collection.json
 hl collections deploy <highlight-id> --wait
 hl collections deploy-status <highlight-id>
 hl collections deploy-cancel <highlight-id>
-```
-
-Creation input uses the SDK's `collection.create` shape:
-
-```json
-{
-  "name": "My Drop",
-  "description": "Created with the Highlight CLI",
-  "type": "OpenEdition",
-  "logoMediaId": "00000000-0000-0000-0000-000000000000",
-  "image": "https://assets.example/art.png",
-  "contract": {
-    "chainId": 84532,
-    "name": "My Drop",
-    "symbol": "DROP",
-    "standard": "ERC721"
-  }
-}
-```
-
-Use `--input -` to read JSON from stdin.
-
-## Sales
 
-```sh
 hl sales list <highlight-id>
 hl sales create <highlight-id> --input sale.json
 hl sales update <highlight-id> <sale-id> --input sale-update.json
 hl sales delete <highlight-id> <sale-id>
-```
 
-Sale input uses the SDK's `collection.addSale` body shape:
-
-```json
-{
-  "type": "FIXED_PRICE",
-  "accessMode": "PUBLIC",
-  "startAt": "2026-01-01T00:00:00.000Z",
-  "price": "0.01",
-  "currency": "ETH",
-  "maxPerTransaction": 5,
-  "maxPerWallet": 10,
-  "maxTotal": 100,
-  "paymentRecipient": "0x0000000000000000000000000000000000000001"
-}
-```
-
-The API enforces the collection functionality matrices. Unsupported
-combinations, such as gated ranked auctions, return the canonical domain error.
-Live public sale changes can return a transaction payload that requires a
-wallet signature.
-
-## Gates
-
-```sh
 hl gates list
 hl gates get <gate-id>
 hl gates create --input gate.json
 hl gates update <gate-id> --input gate-update.json
 hl gates delete <gate-id>
-```
-
-Gate JSON uses the SDK `gate.create` or `gate.update` body shape and supports
-allowlists, token ownership, specific tokens, token attributes, currency
-balances, and Farcaster follows.
 
-## Contracts, tokens, and chains
+hl media upload ./art.png
+hl media upload ./generative-code.zip --kind directory
+hl media get <media-id>
+hl media publish <media-id>
 
-```sh
 hl contracts list
 hl contracts get <contract-id>
 
@@ -129,30 +102,48 @@ hl chains list --testnet
 hl chains system-contract 84532 MintManager
 ```
 
-Token reads and chain configuration are public and do not require credentials.
-Contract queries and token reveal redrives require authentication.
-
-## Media
+Run group help for every option:
 
 ```sh
-hl media upload ./art.png
-hl media upload ./generative-code.zip --kind directory
-hl media get <media-id>
-hl media publish <media-id>
+hl collections --help
+hl sales --help
+hl media --help
 ```
 
-Uploads wait for processing by default. Use `--no-wait` for asynchronous jobs.
+Collection, sale, and gate writes accept JSON with `--input <file>`. Use
+`--input -` to read it from stdin.
+
+## Current boundaries
+
+`hl collections create` creates the base draft. Version `0.1.0` does not
+configure edition, series, or generative details, so complete those fields in
+the dashboard, SDK, or REST API before deployment.
+
+The CLI does not read or store wallet keys. When deployment or a live sale
+change needs an on-chain transaction, it prints the payload for a wallet to
+sign. It does not broadcast that transaction or submit its hash for tracking.
+
+Auction configuration is available through the generic sale commands. Bids,
+claims, standings, settlement, and earnings actions remain SDK or REST
+operations.
 
 ## Automation
 
-Pass `--json` anywhere in the command to receive stable machine-readable
-output:
+Pass `--json` anywhere in a command for machine-readable output:
 
 ```sh
 hl collections list --json
 hl media upload ./art.png --json
 ```
 
-Errors are written to stderr and commands return non-zero exit codes.
+Successful JSON goes to stdout. Errors go to stderr. Commands return:
+
+- `0` on success
+- `1` for API, authentication, filesystem, timeout, or processing failures
+- `2` for invalid commands, options, arguments, or JSON input
 
-Run `hl --help`, `hl collections --help`, or `hl media --help` for all options.
+Pin the package version in production automation:
+
+```sh
+npm install --global @highlightxyz/cli@0.1.0
+```

package/lib/index.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "@highlightxyz/cli",
-  version: "0.1.0",
+  version: "0.3.0",
   description: "Official command-line interface for the Highlight API",
   keywords: [
     "cli",
@@ -18,13 +18,16 @@ var package_default = {
     url: "https://github.com/highlight-xyz/highlight-app.git",
     directory: "packages/cli"
   },
+  bin: {
+    hl: "./lib/index.js"
+  },
   files: [
     "lib",
     "README.md"
   ],
   type: "module",
-  bin: {
-    hl: "./lib/index.js"
+  publishConfig: {
+    access: "public"
   },
   scripts: {
     build: "bun build ./src/index.ts --outfile ./lib/index.js --target node --format esm",
@@ -45,9 +48,6 @@ var package_default = {
   },
   engines: {
     node: ">=20"
-  },
-  publishConfig: {
-    access: "public"
   }
 };
 
@@ -209,6 +209,15 @@ var SaleAccessMode;
   SaleAccessMode2["Public"] = "PUBLIC";
   SaleAccessMode2["Gated"] = "GATED";
 })(SaleAccessMode ||= {});
+var MediaPurpose;
+((MediaPurpose2) => {
+  MediaPurpose2["CollectionLogo"] = "CollectionLogo";
+  MediaPurpose2["EditionImage"] = "EditionImage";
+  MediaPurpose2["EditionAnimation"] = "EditionAnimation";
+  MediaPurpose2["SeriesAssets"] = "SeriesAssets";
+  MediaPurpose2["GenerativeCode"] = "GenerativeCode";
+  MediaPurpose2["UserAvatar"] = "UserAvatar";
+})(MediaPurpose ||= {});
 var GateMatchMode;
 ((GateMatchMode2) => {
   GateMatchMode2["All"] = "ALL";
@@ -1150,8 +1159,6 @@ class Collection extends HeyApiClient {
           { in: "body", key: "description" },
           { in: "body", key: "contractId" },
           { in: "body", key: "contract" },
-          { in: "body", key: "logoMediaId" },
-          { in: "body", key: "image" },
           { in: "body", key: "type" },
           { in: "body", key: "royalty" },
           { in: "body", key: "tokenManager" }
@@ -1223,14 +1230,58 @@ class Collection extends HeyApiClient {
       ...params
     });
   }
-  finalizeBaseUri(parameters, options) {
+  archiveBaseUri(parameters, options) {
     const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "highlightId" }] }]);
     return (options?.client ?? this.client).post({
-      url: "/collection/{highlightId}/finalize-base-uri",
+      url: "/collection/{highlightId}/archive-base-uri",
       ...options,
       ...params
     });
   }
+  createMediaUploadSession(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "body", key: "purpose" },
+          { in: "body", key: "fileName" },
+          { in: "body", key: "mimeType" },
+          { in: "body", key: "fileSize" },
+          { in: "body", key: "contentHash" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/collection/{highlightId}/media/upload-session",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  updateMetadata(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { key: "collectionUpdateMetadataInput", map: "body" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).patch({
+      url: "/collection/{highlightId}/metadata",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
   updateGenerativeDetails(parameters, options) {
     const params = buildClientParams([parameters], [
       {
@@ -1316,7 +1367,6 @@ class Collection extends HeyApiClient {
           { in: "body", key: "paymentRecipient" },
           { in: "body", key: "accessMode" },
           { in: "body", key: "gateId" },
-          { in: "body", key: "gasSponsored" },
           { in: "body", key: "mechanicId" },
           { in: "body", key: "typeConfig" },
           { in: "body", key: "collectorMessage" },
@@ -1553,6 +1603,41 @@ class Collection extends HeyApiClient {
       ...params
     });
   }
+  dutchAuctionStanding(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "path", key: "saleId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/collection/{highlightId}/sales/{saleId}/dutch",
+      ...options,
+      ...params
+    });
+  }
+  claimDutchRebate(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "highlightId" },
+          { in: "body", key: "saleId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/collection/{highlightId}/sales/dutch/rebate",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
   deploy(parameters, options) {
     const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "highlightId" }] }]);
     return (options?.client ?? this.client).post({
@@ -1656,6 +1741,12 @@ class Config extends HeyApiClient {
       ...options
     });
   }
+  mediaHosts(options) {
+    return (options?.client ?? this.client).get({
+      url: "/config/media-hosts",
+      ...options
+    });
+  }
   systemContract(parameters, options) {
     const params = buildClientParams([parameters], [
       {
@@ -1967,41 +2058,10 @@ class Mechanic extends HeyApiClient {
 }
 
 class Media extends HeyApiClient {
-  createUploadSession(parameters, options) {
-    const params = buildClientParams([parameters], [
-      {
-        args: [
-          { in: "body", key: "kind" },
-          { in: "body", key: "scope" },
-          { in: "body", key: "fileName" },
-          { in: "body", key: "mimeType" },
-          { in: "body", key: "fileSize" }
-        ]
-      }
-    ]);
-    return (options?.client ?? this.client).post({
-      url: "/media/upload-session",
-      ...options,
-      ...params,
-      headers: {
-        "Content-Type": "application/json",
-        ...options?.headers,
-        ...params.headers
-      }
-    });
-  }
-  upload(parameters, options) {
-    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "mediaId" }] }]);
-    return (options?.client ?? this.client).put({
-      url: "/media/{mediaId}/upload",
-      ...options,
-      ...params
-    });
-  }
-  process(parameters, options) {
+  finalizeUpload(parameters, options) {
     const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "mediaId" }] }]);
     return (options?.client ?? this.client).post({
-      url: "/media/{mediaId}/process",
+      url: "/media/{mediaId}/finalize",
       ...options,
       ...params
     });
@@ -2103,6 +2163,29 @@ class Siwe extends HeyApiClient {
 }
 
 class User extends HeyApiClient {
+  createMediaUploadSession(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "body", key: "purpose" },
+          { in: "body", key: "fileName" },
+          { in: "body", key: "mimeType" },
+          { in: "body", key: "fileSize" },
+          { in: "body", key: "contentHash" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).post({
+      url: "/user/media/upload-session",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
   signin(parameters, options) {
     const params = buildClientParams([parameters], [{ args: [{ key: "body", map: "body" }] }]);
     return (options?.client ?? this.client).post({
@@ -2122,6 +2205,62 @@ class User extends HeyApiClient {
   }
 }
 
+class Profile extends HeyApiClient {
+  get(options) {
+    return (options?.client ?? this.client).get({ url: "/user/profile", ...options });
+  }
+  update(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "body", key: "displayName" },
+          { in: "body", key: "bio" },
+          { in: "body", key: "website" },
+          { in: "body", key: "avatarMediaId" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).patch({
+      url: "/user/profile",
+      ...options,
+      ...params,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers,
+        ...params.headers
+      }
+    });
+  }
+  public(parameters, options) {
+    const params = buildClientParams([parameters], [{ args: [{ in: "path", key: "walletAddress" }] }]);
+    return (options?.client ?? this.client).get({
+      url: "/user/{walletAddress}/profile",
+      ...options,
+      ...params
+    });
+  }
+  tokens(parameters, options) {
+    const params = buildClientParams([parameters], [
+      {
+        args: [
+          { in: "path", key: "walletAddress" },
+          { in: "query", key: "page" },
+          { in: "query", key: "limit" },
+          { in: "query", key: "sort" },
+          { in: "query", key: "order" },
+          { in: "query", key: "collectionId" },
+          { in: "query", key: "search" }
+        ]
+      }
+    ]);
+    return (options?.client ?? this.client).get({
+      url: "/user/{walletAddress}/tokens",
+      ...options,
+      ...params
+    });
+  }
+}
+
 class ApiKey extends HeyApiClient {
   list(options) {
     return (options?.client ?? this.client).get({ url: "/user/api-keys", ...options });
@@ -2243,6 +2382,10 @@ class HighlightClient extends HeyApiClient {
   get user() {
     return this._user ??= new User({ client: this.client });
   }
+  _profile;
+  get profile() {
+    return this._profile ??= new Profile({ client: this.client });
+  }
   _apiKey;
   get apiKey() {
     return this._apiKey ??= new ApiKey({ client: this.client });
@@ -2263,7 +2406,406 @@ function createHighlightClient(config) {
   const client2 = createClient(resolvedConfig);
   return new HighlightClient({ client: client2 });
 }
+// ../../node_modules/@noble/hashes/esm/utils.js
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function clean(...arrays) {
+  for (let i = 0;i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotr(word, shift) {
+  return word << 32 - shift | word >>> shift;
+}
+var hasHexBuiltin = /* @__PURE__ */ (() => typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function")();
+var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  abytes(bytes);
+  if (hasHexBuiltin)
+    return bytes.toHex();
+  let hex = "";
+  for (let i = 0;i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+class Hash {
+}
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+
+// ../../node_modules/@noble/hashes/esm/_md.js
+function setBigUint64(view, byteOffset, value, isLE) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE ? 4 : 0;
+  const l = isLE ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE);
+  view.setUint32(byteOffset + l, wl, isLE);
+}
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+
+class HashMD extends Hash {
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    super();
+    this.finished = false;
+    this.length = 0;
+    this.pos = 0;
+    this.destroyed = false;
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists(this);
+    data = toBytes(data);
+    abytes(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0;pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (;blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos;i < blockLen; i++)
+      buffer[i] = 0;
+    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0;i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to || (to = new this.constructor);
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// ../../node_modules/@noble/hashes/esm/sha2.js
+var SHA256_K = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+
+class SHA256 extends HashMD {
+  constructor(outputLen = 32) {
+    super(64, outputLen, 8, false);
+    this.A = SHA256_IV[0] | 0;
+    this.B = SHA256_IV[1] | 0;
+    this.C = SHA256_IV[2] | 0;
+    this.D = SHA256_IV[3] | 0;
+    this.E = SHA256_IV[4] | 0;
+    this.F = SHA256_IV[5] | 0;
+    this.G = SHA256_IV[6] | 0;
+    this.H = SHA256_IV[7] | 0;
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0;i < 16; i++, offset += 4)
+      SHA256_W[i] = view.getUint32(offset, false);
+    for (let i = 16;i < 64; i++) {
+      const W15 = SHA256_W[i - 15];
+      const W2 = SHA256_W[i - 2];
+      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let i = 0;i < 64; i++) {
+      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+      const T2 = sigma0 + Maj(A, B, C) | 0;
+      H = G;
+      G = F;
+      F = E;
+      E = D + T1 | 0;
+      D = C;
+      C = B;
+      B = A;
+      A = T1 + T2 | 0;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    F = F + this.F | 0;
+    G = G + this.G | 0;
+    H = H + this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    clean(SHA256_W);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    clean(this.buffer);
+  }
+}
+var sha256 = /* @__PURE__ */ createHasher(() => new SHA256);
+
 // ../sdk/src/v1/media.ts
+var isReadableStream = (source) => ("getReader" in source);
+var sha256MediaContent = async (source, options) => {
+  const hasher = sha256.create();
+  let bytesHashed = 0;
+  const update = (chunk) => {
+    if (options?.signal?.aborted) {
+      throw new DOMException("Hashing aborted.", "AbortError");
+    }
+    hasher.update(chunk);
+    bytesHashed += chunk.byteLength;
+    options?.onProgress?.(bytesHashed);
+  };
+  if (isReadableStream(source)) {
+    const reader = source.getReader();
+    try {
+      while (true) {
+        const result = await reader.read();
+        if (result.done)
+          break;
+        update(result.value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  } else {
+    for await (const chunk of source)
+      update(chunk);
+  }
+  return `sha256:${bytesToHex(hasher.digest())}`;
+};
+var SUPPORTED_IMAGE_CONTENT_TYPES = new Set([
+  "image/avif",
+  "image/gif",
+  "image/heic",
+  "image/heif",
+  "image/jpeg",
+  "image/jpg",
+  "image/png",
+  "image/webp"
+]);
+var DEFAULT_MEDIA_DELIVERY_HOSTS = {
+  assets: "https://assets.highlight.xyz",
+  metadata: "https://metadata.highlight.xyz",
+  legacyAssets: "https://highlight-creator-assets.highlight.xyz",
+  arweaveGateway: "https://arweave.net",
+  ipfsGateway: "https://ipfs.io"
+};
+var LEGACY_REFERENCE = /^main\//;
+var mediaUrl = (media, location, hosts = DEFAULT_MEDIA_DELIVERY_HOSTS) => {
+  switch (location.provider) {
+    case "R2" /* R2 */: {
+      if (LEGACY_REFERENCE.test(location.reference)) {
+        return `${hosts.legacyAssets}/${location.reference}`;
+      }
+      if (media.parentId && media.path) {
+        return `${hosts.assets}/${media.parentId}/${media.path}`;
+      }
+      return media.kind === "Directory" /* Directory */ ? `${hosts.assets}/${media.id}/` : `${hosts.assets}/${media.id}`;
+    }
+    case "Arweave" /* Arweave */:
+      return `${hosts.arweaveGateway}/${location.reference}`;
+    case "IPFS" /* Ipfs */:
+      return `${hosts.ipfsGateway}/ipfs/${location.reference.replace(/^ipfs:\/\//, "").replace(/^\//, "")}`;
+    case "External" /* External */:
+      return location.reference;
+    default:
+      return null;
+  }
+};
 var DEFAULT_PREFERENCE = [
   "Archive" /* Archive */,
   "Origin" /* Origin */,
@@ -2271,7 +2813,7 @@ var DEFAULT_PREFERENCE = [
 ];
 var pickLocation = (media, preference) => {
   for (const role of preference) {
-    const location = media.locations.find((l) => l.role === role && l.status === "Succeeded" /* Succeeded */ && l.url !== null);
+    const location = media.locations.find((l) => l.role === role && l.status === "Succeeded" /* Succeeded */);
     if (location)
       return location;
   }
@@ -2281,12 +2823,13 @@ var resolveMediaUrl = (media, options) => {
   if (!media)
     return null;
   const preference = options?.prefer ? Array.isArray(options.prefer) ? options.prefer : [options.prefer] : DEFAULT_PREFERENCE;
-  return pickLocation(media, preference)?.url ?? null;
+  const location = pickLocation(media, preference);
+  return location ? mediaUrl(media, location, options?.hosts) : null;
 };
 // src/config.ts
 import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
-var DEFAULT_API_URL = "https://api.highlightv2.xyz";
+var DEFAULT_API_URL = "https://api.highlight.xyz";
 var CONFIG_VERSION = 1;
 var defaultConfig = () => ({
   currentProfile: "default",
@@ -2693,7 +3236,7 @@ var requiredInputPath = (inputPath) => {
 var isCollectionCreateInput = (value) => {
   if (!isRecord3(value))
     return false;
-  if (typeof value.name !== "string" || typeof value.description !== "string" || typeof value.logoMediaId !== "string" || typeof value.image !== "string" || !Object.values(CollectionType).includes(value.type) || !isOptionalString(value.contractId) || !isOptionalString(value.tokenManager)) {
+  if (typeof value.name !== "string" || typeof value.description !== "string" || typeof value.logoMediaId !== "string" || !Object.values(CollectionType).includes(value.type) || !isOptionalString(value.contractId) || !isOptionalString(value.tokenManager)) {
     return false;
   }
   if (value.contract !== undefined) {
@@ -2782,7 +3325,7 @@ var create = async (args, global, runtime) => {
   });
   assertNoExtraPositionals(parsed.positionals, 0);
   const inputPath = requiredInputPath(parsed.values.input);
-  const input = await readTypedJsonInput(inputPath, runtime, isCollectionCreateInput, "a collection.create object containing name, description, logoMediaId, image, type, and valid contract details");
+  const input = await readTypedJsonInput(inputPath, runtime, isCollectionCreateInput, "a collection.create object containing name, description, logoMediaId, type, and valid contract details");
   const context = await createClientContext(runtime, global);
   const collection = unwrap(await context.client.collection.create(input));
   if (global.json) {
@@ -3000,8 +3543,10 @@ var remove = async (args, global, runtime) => {
 };
 
 // src/commands/media.ts
-import { readFile as readFile3, stat } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
 import path3 from "node:path";
+import { Readable } from "node:stream";
 var MIME_TYPES = {
   ".css": "text/css",
   ".gif": "image/gif",
@@ -3047,11 +3592,11 @@ var waitUntilReady = async (mediaId, initial, timeoutSeconds, pollIntervalSecond
 var upload = async (args, global, runtime) => {
   const parsed = parseCommandArgs(args, {
     options: {
-      kind: { type: "string" },
+      collection: { type: "string" },
       "mime-type": { type: "string" },
       "no-wait": { type: "boolean" },
       "poll-interval": { type: "string" },
-      scope: { type: "string" },
+      purpose: { type: "string" },
       timeout: { type: "string" }
     }
   });
@@ -3062,40 +3607,45 @@ var upload = async (args, global, runtime) => {
   if (!fileStat.isFile()) {
     throw new CliError(`Media input must be a file: ${inputPath}`, 2);
   }
-  const kindValue = parsed.values.kind?.toLowerCase() ?? "file";
-  const kind = kindValue === "file" ? "File" /* File */ : kindValue === "directory" ? "Directory" /* Directory */ : undefined;
-  if (!kind) {
-    throw new CliError('--kind must be either "file" or "directory"', 2);
+  const purposes = Object.values(MediaPurpose);
+  const purpose = purposes.find((value) => value === parsed.values.purpose);
+  if (!purpose) {
+    throw new CliError(`--purpose must be one of: ${purposes.join(", ")}`, 2);
   }
-  if (kind === "Directory" /* Directory */ && path3.extname(absolutePath).toLowerCase() !== ".zip") {
-    throw new CliError("Directory media must be uploaded as a .zip file", 2);
+  const collectionId = parsed.values.collection;
+  const needsCollection = purpose !== "UserAvatar" /* UserAvatar */;
+  if (needsCollection && !collectionId) {
+    throw new CliError(`--collection is required for ${purpose} uploads`, 2);
   }
-  const scopeValue = parsed.values.scope?.toLowerCase() ?? "collection";
-  const scope = scopeValue === "collection" ? "Collection" /* Collection */ : scopeValue === "user" ? "User" /* User */ : undefined;
-  if (!scope) {
-    throw new CliError('--scope must be either "collection" or "user"', 2);
+  if (!needsCollection && collectionId) {
+    throw new CliError(`--collection is not valid for ${purpose} uploads`, 2);
   }
+  const contentHash = await sha256MediaContent(createReadStream(absolutePath));
   const context = await createClientContext(runtime, global);
-  const session = unwrap(await context.client.media.createUploadSession({
+  const body = {
     fileName: path3.basename(absolutePath),
     fileSize: fileStat.size,
-    kind,
     mimeType: parsed.values["mime-type"] ?? mimeTypeFor(absolutePath),
-    scope
-  }));
+    purpose,
+    contentHash
+  };
+  const session = unwrap(collectionId ? await context.client.collection.createMediaUploadSession({
+    highlightId: collectionId,
+    ...body
+  }) : await context.client.user.createMediaUploadSession(body));
   const headers = new Headers(session.upload.headers);
-  if (!headers.has("authorization")) {
-    headers.set("authorization", `Bearer ${context.apiKey}`);
-  }
   const response = await runtime.fetch(session.upload.url, {
-    body: await readFile3(absolutePath),
+    body: Readable.toWeb(createReadStream(absolutePath)),
+    duplex: "half",
     headers,
     method: session.upload.method
   });
   if (!response.ok) {
     throw new ApiError(await parseResponseError(response), response.status);
   }
-  let media2 = unwrap(await context.client.media.get({ mediaId: session.media.id }));
+  let media2 = unwrap(await context.client.media.finalizeUpload({
+    mediaId: session.uploadMediaId
+  }));
   if (!parsed.values["no-wait"]) {
     media2 = await waitUntilReady(media2.id, media2, positiveNumber(parsed.values.timeout, "--timeout") ?? 300, positiveNumber(parsed.values["poll-interval"], "--poll-interval") ?? 2, runtime, async () => unwrap(await context.client.media.get({ mediaId: media2.id })));
   }
@@ -3139,7 +3689,7 @@ var isOptionalBoolean = (value) => value === undefined || typeof value === "bool
 var isSaleCreateInput = (value) => {
   if (!isRecord3(value))
     return false;
-  return Object.values(SaleType).includes(value.type) && typeof value.startAt === "string" && typeof value.price === "string" && typeof value.currency === "string" && typeof value.maxPerTransaction === "number" && Number.isFinite(value.maxPerTransaction) && typeof value.maxPerWallet === "number" && Number.isFinite(value.maxPerWallet) && typeof value.maxTotal === "number" && Number.isFinite(value.maxTotal) && typeof value.paymentRecipient === "string" && isOptionalNullableString(value.name) && isOptionalNullableString(value.endAt) && (value.accessMode === undefined || Object.values(SaleAccessMode).includes(value.accessMode)) && isOptionalNullableString(value.gateId) && isOptionalBoolean(value.gasSponsored) && isOptionalNullableString(value.mechanicId) && isOptionalNullableString(value.collectorMessage) && isOptionalNullableString(value.customMintFee);
+  return Object.values(SaleType).includes(value.type) && typeof value.startAt === "string" && typeof value.price === "string" && typeof value.currency === "string" && typeof value.maxPerTransaction === "number" && Number.isFinite(value.maxPerTransaction) && typeof value.maxPerWallet === "number" && Number.isFinite(value.maxPerWallet) && typeof value.maxTotal === "number" && Number.isFinite(value.maxTotal) && typeof value.paymentRecipient === "string" && isOptionalNullableString(value.name) && isOptionalNullableString(value.endAt) && (value.accessMode === undefined || Object.values(SaleAccessMode).includes(value.accessMode)) && isOptionalNullableString(value.gateId) && isOptionalNullableString(value.mechanicId) && isOptionalNullableString(value.collectorMessage) && isOptionalNullableString(value.customMintFee);
 };
 var SALE_UPDATE_FIELDS = [
   "name",
@@ -3490,8 +4040,10 @@ var MEDIA_HELP = `Usage:
   hl media publish <media-id>
 
 Upload options:
-  --kind <file|directory>            Directory inputs must be .zip files
-  --scope <collection|user>          Media scope (default: collection)
+  --purpose <purpose>                Required. CollectionLogo, EditionImage,
+                                     EditionAnimation, SeriesAssets,
+                                     GenerativeCode, or UserAvatar
+  --collection <highlight-id>        Required for every purpose except UserAvatar
   --mime-type <type>                 Override inferred MIME type
   --no-wait                          Return before processing is ready
   --timeout <seconds>                Wait timeout (default: 300)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@highlightxyz/cli",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Official command-line interface for the Highlight API",
   "keywords": [
     "cli",
@@ -16,13 +16,16 @@
     "url": "https://github.com/highlight-xyz/highlight-app.git",
     "directory": "packages/cli"
   },
+  "bin": {
+    "hl": "./lib/index.js"
+  },
   "files": [
     "lib",
     "README.md"
   ],
   "type": "module",
-  "bin": {
-    "hl": "./lib/index.js"
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
     "build": "bun build ./src/index.ts --outfile ./lib/index.js --target node --format esm",
@@ -43,8 +46,5 @@
   },
   "engines": {
     "node": ">=20"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }