@eluvio/elv-client-js 4.2.29 → 4.2.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eluvio/elv-client-js",
-  "version": "4.2.29",
+  "version": "4.2.31",
   "description": "Javascript client for the Eluvio Content Fabric",
   "main": "src/index.js",
   "author": "Kevin Talmadge",

package/src/AuthorizationClient.js

@@ -3,6 +3,7 @@ const Ethers = require("ethers");
 const Utils = require("./Utils");
 const UrlJoin = require("url-join");
 const {LogMessage} = require("./LogMessage");
+const {ValidateObject, ValidateParameters} = require("./Validation");
 
 /*
 // -- Contract javascript files built using build/BuildContracts.js
@@ -119,6 +120,10 @@ class AuthorizationClient {
   }) {
     if(versionHash) { objectId = this.client.utils.DecodeVersionHash(versionHash).objectId; }
 
+    if(update && !objectId) {
+      throw Error("An objectId or versionHash is required when 'update' is true");
+    }
+
     const isWalletRequest =
       objectId &&
       this.client.signer &&

package/src/ElvClient.js

@@ -131,6 +131,7 @@ class ElvClient {
    * @param {Array<string>} authServiceURIs - A list of full URIs to auth service endpoints
    * @param {Array<string>} fileServiceURIs - A list of full URIs to file service endpoints
    * @param {Array<string>=} searchURIs - A list of full URIs to search service endpoints
+   * @param {Array<string>=} tenantQueryURIs - A list of full URIs to tenant query service endpoints
    * @param {number=} ethereumContractTimeout=10 - Number of seconds to wait for contract calls
    * @param {string=} trustAuthorityId - (OAuth) The ID of the trust authority to use for OAuth authentication
    * @param {string=} staticToken - Static token that will be used for all authorization in place of normal auth. Also known as an anonymous token containing the space
@@ -152,6 +153,7 @@ class ElvClient {
     authServiceURIs,
     fileServiceURIs,
     searchURIs,
+    tenantQueryURIs,
     ethereumContractTimeout = 10,
     trustAuthorityId,
     staticToken,
@@ -179,6 +181,7 @@ class ElvClient {
     this.fileServiceURIs = fileServiceURIs || fabricURIs;
     this.ethereumURIs = ethereumURIs;
     this.searchURIs = searchURIs;
+    this.tenantQueryURIs = tenantQueryURIs || [];
     this.ethereumContractTimeout = ethereumContractTimeout;
 
     this.trustAuthorityId = trustAuthorityId;
@@ -262,6 +265,11 @@ class ElvClient {
 
       const searchURIs = fabricInfo.network.services.search || [];
 
+      let tenantQueryURIs = fabricInfo.network.services.tenant_query || [];
+      if(tenantQueryURIs.find(filterHTTPS)) {
+        tenantQueryURIs = tenantQueryURIs.filter(filterHTTPS);
+      }
+
       const fabricVersion = Math.max(...(fabricInfo.network.api_versions || [2]));
 
       return {
@@ -275,6 +283,7 @@ class ElvClient {
         fileServiceURIs,
         kmsURIs: kmsUrls,
         searchURIs,
+        tenantQueryURIs,
         fabricVersion
       };
     } catch(error) {
@@ -378,6 +387,7 @@ class ElvClient {
       authServiceURIs,
       fileServiceURIs,
       searchURIs,
+      tenantQueryURIs,
       fabricVersion
     } = await ElvClient.Configuration({
       configUrl,
@@ -395,6 +405,7 @@ class ElvClient {
       authServiceURIs,
       fileServiceURIs,
       searchURIs,
+      tenantQueryURIs,
       ethereumContractTimeout,
       trustAuthorityId,
       staticToken,
@@ -427,6 +438,7 @@ class ElvClient {
     this.AuthHttpClient = new HttpClient({uris: this.authServiceURIs, networkName: this.networkName, debug: this.debug});
     this.FileServiceHttpClient = new HttpClient({uris: this.fileServiceURIs, networkName: this.networkName, debug: this.debug});
     this.SearchHttpClient = new HttpClient({uris: this.searchURIs || [], networkName: this.networkName, debug: this.debug});
+    this.TenantQueryHttpClient = new HttpClient({uris: this.tenantQueryURIs || [], networkName: this.networkName, debug: this.debug});
     this.ethClient = new EthClient({client: this, uris: this.ethereumURIs, networkId: this.networkId, debug: this.debug, timeout: this.ethereumContractTimeout});
 
     if(!this.signer) {
@@ -483,7 +495,7 @@ class ElvClient {
       throw Error("Unable to change region: Configuration URL not set");
     }
 
-    const {fabricURIs, ethereumURIs, authServiceURIs, fileServiceURIs, searchURIs} = await ElvClient.Configuration({
+    const {fabricURIs, ethereumURIs, authServiceURIs, fileServiceURIs, searchURIs, tenantQueryURIs} = await ElvClient.Configuration({
       configUrl: this.configUrl,
       region
     });
@@ -495,7 +507,8 @@ class ElvClient {
       ethereumURIs,
       authServiceURIs,
       fileServiceURIs,
-      searchURIs
+      searchURIs,
+      tenantQueryURIs
     });
 
     return {
@@ -503,7 +516,8 @@ class ElvClient {
       ethereumURIs,
       fileServiceURIs,
       authServiceURIs,
-      searchURIs
+      searchURIs,
+      tenantQueryURIs
     };
   }
 
@@ -558,7 +572,8 @@ class ElvClient {
       ethereumURIs: this.ethereumURIs,
       authServiceURIs: this.authServiceURIs,
       fileServiceURIs: this.fileServiceURIs,
-      searchURIs: this.searchURIs
+      searchURIs: this.searchURIs,
+      tenantQueryURIs: this.tenantQueryURIs
     };
   }
 
@@ -571,10 +586,11 @@ class ElvClient {
    * @param {Array<string>=} authServiceURIs - A list of URLs for the auth service, in preference order
    * @param {Array<string>=} fileServiceURIs - A list of URLs for file service jobs, in preference order
    * @param {Array<string>=} searchURIs - A list of URLs for the search nodes, in preference order
+   * @param {Array<string>=} tenantQueryURIs - A list of URLs for the tenant query nodes, in preference order
    *
    * @methodGroup Nodes
    */
-  SetNodes({fabricURIs, ethereumURIs, authServiceURIs, fileServiceURIs, searchURIs}) {
+  SetNodes({fabricURIs, ethereumURIs, authServiceURIs, fileServiceURIs, searchURIs, tenantQueryURIs}) {
     if(fabricURIs) {
       this.fabricURIs = fabricURIs;
 
@@ -609,6 +625,13 @@ class ElvClient {
       this.SearchHttpClient.uris = searchURIs;
       this.SearchHttpClient.uriIndex = 0;
     }
+
+    if(tenantQueryURIs) {
+      this.tenantQueryURIs = tenantQueryURIs;
+
+      this.TenantQueryHttpClient.uris = tenantQueryURIs;
+      this.TenantQueryHttpClient.uriIndex = 0;
+    }
   }
 
   /**
@@ -936,6 +959,57 @@ class ElvClient {
     json                    79b  {"adr":"VVf4DQU357tDnZGYQeDrntRJ5rs=","spc":"ispc3ANoVSzNA3P6t7abLR69ho5YPPZU"}
    */
 
+  /*
+    PLAIN TOKEN  PREFIX + BODY | aplsjcJf1HYcDDUuCdXcSZtU86nYK162YmYJeuqwMczEBJVkD5D5EvsBvVwYDRsf4hzDvBWMoe9piBpqx...
+    PREFIX       6b  aplsjc | apl=plain s=ES256K jc=json-compressed
+    BODY             base58(SIGNATURE + PAYLOAD)
+    SIGNATURE   65b  ES256K signature
+    PAYLOAD          raw-deflate JSON
+    json             {"adr":"VVf4DQU357tDnZGYQeDrntRJ5rs=","spc":"ispc3ANoVSzNA3P6t7abLR69ho5YPPZU"}
+   */
+
+  /**
+   * Create a signed "plain" authorization token (`aplsjc...`).
+   *
+   * Plain tokens are largely the same as client-signed access tokens - they do not contain a b/c transaction
+   * and authorization is determined from the rights of the current signer's address.
+   * Currently needed for tenant content query /tenant/:tid/q/query
+   * This token will be deprecated in the future in favor of client-signed access tokens.
+   *
+   * @methodGroup Authorization
+   * @namedParams
+   * @param {string=} libraryId - Optional library ID to scope the token. If omitted, the token is space-wide.
+   * @returns {Promise<string>} - The signed Plain auth token
+   */
+  async CreatePlainToken({libraryId}={}) {
+    const address = this.CurrentAccountAddress();
+    if(!address) {
+      throw Error("Unable to create plain token: No signer is configured");
+    }
+
+    const token = {
+      adr: Buffer.from(address.replace(/^0x/, ""), "hex").toString("base64"),
+      spc: await this.ContentSpaceId()
+    };
+
+    if(libraryId) {
+      token.lib = libraryId;
+    }
+
+    const compressedToken = Pako.deflateRaw(Buffer.from(JSON.stringify(token), "utf-8"));
+    const signature = await this.authClient.Sign(Ethers.utils.keccak256(compressedToken));
+    const signatureBytes = Buffer.from(signature.replace(/^0x/, ""), "hex");
+
+    if(signatureBytes.length !== 65) {
+      throw Error("Unable to create plain token: Expected a 65-byte ES256K signature");
+    }
+
+    return `aplsjc${this.utils.B58(Buffer.concat([
+      signatureBytes,
+      Buffer.from(compressedToken)
+    ]))}`;
+  }
+
   async PersonalSign({
     message,
     addEthereumPrefix,

package/src/FrameClient.js

@@ -316,6 +316,9 @@ class FrameClient {
       "AddAccessGroupMember",
       "AddContentLibraryGroup",
       "AddContentObjectGroupPermission",
+      "AddContentObjectGroups",
+      "AddContentObjectQueryFields",
+      "AddContentObjectTags",
       "AddLibraryContentType",
       "AssetMetadata",
       "AuditContentObject",
@@ -341,10 +344,13 @@ class FrameClient {
       "ContentObjectAccessComplete",
       "ContentObjectGraph",
       "ContentObjectGroupPermissions",
+      "ContentObjectGroups",
       "ContentObjectImageUrl",
       "ContentObjectLibraryId",
       "ContentObjectMetadata",
       "ContentObjectOwner",
+      "ContentObjectQueryFields",
+      "ContentObjectTags",
       "ContentObjectTenantId",
       "ContentObjectVersions",
       "ContentObjects",
@@ -364,6 +370,7 @@ class FrameClient {
       "CreateAccessGroup",
       "CreateAndFinalizeContentObject",
       "CreateAuthorizationToken",
+      "CreateContentGroup",
       "CreateContentLibrary",
       "CreateContentObject",
       "CreateContentType",
@@ -375,6 +382,7 @@ class FrameClient {
       "CreateNTPInstance",
       "CreateNonOwnerCap",
       "CreatePart",
+      "CreatePlainToken",
       "CreateProductionMaster",
       "CreateShare",
       "CreateSignedMessageJSON",
@@ -450,6 +458,7 @@ class FrameClient {
       "OutputsCreate",
       "OutputsDelete",
       "OutputsDeleteBatch",
+      "OutputsHop",
       "OutputsList",
       "OutputsListItem",
       "OutputsModify",
@@ -473,6 +482,9 @@ class FrameClient {
       "RemoveAccessGroupMember",
       "RemoveContentObjectGroupPermission",
       "RemoveContentLibraryGroup",
+      "RemoveContentObjectGroups",
+      "RemoveContentObjectQueryFields",
+      "RemoveContentObjectTags",
       "RemoveLibraryContentType",
       "Rep",
       "ReplaceContractMetadata",
@@ -488,7 +500,10 @@ class FrameClient {
       "SetAuthContext",
       "SetAuthPolicy",
       "SetContentLibraryImage",
+      "SetContentObjectGroups",
       "SetContentObjectImage",
+      "SetContentObjectQueryFields",
+      "SetContentObjectTags",
       "SetCustomContentContract",
       "SetGroupPermission",
       "SetNodes",
@@ -531,6 +546,7 @@ class FrameClient {
       "StreamUnassignProfile",
       "StreamUpdateConfig",
       "SuspendNTPInstance",
+      "TenantContent",
       "TenantContractId",
       "TenantId",
       "UnlinkAccessGroupFromOauth",

package/src/client/ContentAccess.js

@@ -3305,3 +3305,195 @@ exports.QParts = async function({libraryId, objectId, partHash, format="blob"})
     })
   );
 };
+
+/* Content groups */
+
+/**
+ * Retrieve a content object property ("tags", "groups" or "query_fields").
+ *
+ * @private
+ */
+const ContentObjectProperty = async function({objectId, versionHash, writeToken, property}) {
+  if(writeToken && versionHash) {
+    throw Error(`Cannot specify writeToken and versionHash at same time (token:${writeToken}, hash:${versionHash})`);
+  }
+
+  if(writeToken) {
+    ValidateWriteToken(writeToken);
+  } else if(versionHash) {
+    ValidateVersion(versionHash);
+  } else {
+    ValidateObject(objectId);
+  }
+
+  if(writeToken) {
+    objectId = this.utils.DecodeWriteToken(writeToken).objectId;
+  } else if(versionHash) {
+    objectId = this.utils.DecodeVersionHash(versionHash).objectId;
+  }
+
+  const token = await this.GenerateStateChannelToken({
+    objectId,
+    versionHash
+  });
+
+  return this.HttpClient.RequestJsonBody({
+    headers: {Authorization: `Bearer ${token}`},
+    method: "GET",
+    path: UrlJoin("q", writeToken || versionHash || objectId, property)
+  });
+};
+
+/**
+ * Get content tags
+ *
+ * @methodGroup Content Groups
+ * @namedParams
+ * @param {string=} objectId - ID of the object
+ * @param {string=} versionHash - Hash of the object version
+ * @param {string=} writeToken - Write token of the draft
+ *
+ * @returns {Promise<Array<string>>} - The content object tags
+ */
+exports.ContentObjectTags = async function({objectId, versionHash, writeToken}) {
+  this.Log(`Retrieving content tags: ${writeToken || versionHash || objectId}`);
+
+  return ContentObjectProperty.call(this, {objectId, versionHash, writeToken, property: "tags"});
+};
+
+/**
+ * Get content query fields
+ *
+ * @methodGroup Content Groups
+ * @namedParams
+ * @param {string=} objectId - ID of the object
+ * @param {string=} versionHash - Hash of the object version
+ * @param {string=} writeToken - Write token of the draft
+ *
+ * @returns {Promise<Object<string, string>>} - The content object query fields
+ */
+exports.ContentObjectQueryFields = async function({objectId, versionHash, writeToken}) {
+  this.Log(`Retrieving content query fields: ${writeToken || versionHash || objectId}`);
+
+  return ContentObjectProperty.call(this, {objectId, versionHash, writeToken, property: "query_fields"});
+};
+
+/**
+ * Get the groups a content object belongs to
+ *
+ * @methodGroup Content Groups
+ * @namedParams
+ * @param {string=} objectId - ID of the object
+ * @param {string=} versionHash - Hash of the object version
+ * @param {string=} writeToken - Write token of the draft
+ *
+ * @returns {Promise<Array<string>>} - The content groups the object belongs to
+ */
+exports.ContentObjectGroups = async function({objectId, versionHash, writeToken}) {
+  this.Log(`Retrieving content object groups: ${writeToken || versionHash || objectId}`);
+
+  return ContentObjectProperty.call(this, {objectId, versionHash, writeToken, property: "groups"});
+};
+
+/**
+ * Query tenant content.
+ *
+ * The response is based on the fabric index and can use groups, query_fields and tags for filtering and sorting.
+ * The response may include metadata fields as specified in select/remove.
+ *
+ * @methodGroup Tenants
+ * @namedParams
+ * @param {string=} tenantId - ID of the tenant to query. Defaults to the tenant of the current user
+ * @param {Array<string>=} filter - Filter expressions of the form `<field>:<comparator>:<value>`, e.g.
+ *  `tag:eq:elv:media:live_stream` or `qf.date:ge:2026-09-01`. Multiple expressions are combined with AND.
+ *
+ *  Comparators: `::` or `:co:` contains, `:nc:` not contains, `:eq:` equals, `:ne:` not equals,
+ *  `:lt:` less than, `:le:` less than or equal, `:gt:` greater than, `:ge:` greater than or equal.
+ *  Comparisons are lexicographic string comparisons. `:sw:` and `:ew:` are not supported here.
+ *
+ *  Reserved fields:
+ *  - `tag` - matches when *any one* of the object's tags satisfies the expression
+ *  - `group` - ID of a content group the object belongs to
+ *  - `unique_group.id`, `unique_group.type`
+ *  - `lib`, `library` - library ID. Supports `:eq:` only
+ *  - `created_block_time` - when the latest version was created. Comparison operators only
+ *
+ *  Any other field name is treated as a query field name. Prefix with `qf.` to filter on a query field
+ *  whose name collides with a reserved one, e.g. `qf.tag:eq:x`. `created_block_number` is no longer
+ *  supported and is rejected.
+ *
+ * @param {string=} sortBy - Name of a query field to sort by. This is a query field name, not a metadata path,
+ *  and only one may be given. When omitted, results are sorted by the time the latest version was created.
+ *
+ *  Note that sorting by a query field also restricts the results to objects that have that field
+ * @param {boolean=} sortDescending=false - Sort in descending order
+ * @param {(Array<string> | string)=} include - Index data to return alongside each result. Tokens:
+ *  `tags`, `groups`, `uniquegroups`, `fields` (query fields), `type`, `name`, `all`, `none`. May be given
+ *  as an array or as a comma-separated string. The Fabric defaults to query fields only; `none` suppresses
+ *  all index data, including those
+ * @param {Array<string>=} select - Metadata subtree paths to include in each result. If omitted, no metadata
+ *  is retrieved at all and each result contains only its IDs and index data
+ * @param {Array<string>=} remove - Metadata subtree paths to omit from each result. Only has an effect when
+ *  `select` is also specified
+ * @param {number=} start - Index of the first object to retrieve. Defaults to the first
+ * @param {number=} limit - Maximum number of objects to return. Defaults to 100, capped at 998
+ * @param {string=} authorizationToken - Additional authorization token for the request
+ *
+ * @returns {Promise<Object>} - The query result, including `versions` and `paging` information. One entry per
+ *  content object - the index holds only the latest version - carrying `id`, `hash`, `qlib_id`,
+ *  `last_modified_at` and whatever `include` selects - by default the object's query fields
+ */
+exports.TenantContent = async function({
+  tenantId,
+  filter=[],
+  sortBy,
+  sortDescending,
+  include,
+  select=[],
+  remove=[],
+  start,
+  limit,
+  authorizationToken
+}) {
+  tenantId = tenantId || await this.userProfileClient.TenantContractId();
+  ValidatePresence("tenantId", tenantId);
+
+  this.Log(`Querying content for tenant ${tenantId}`);
+
+  const path = UrlJoin("tenants", tenantId, "q", "query");
+
+  // Tenant query works best with plain token - it allows it to return objecte metadata fields.
+  const token = authorizationToken || await this.CreatePlainToken();
+
+  const httpClient =
+    this.TenantQueryHttpClient && this.TenantQueryHttpClient.uris && this.TenantQueryHttpClient.uris.length > 0
+      ? this.TenantQueryHttpClient
+      : this.HttpClient;
+
+  const queryParams = {
+    filter,
+    sort_by: sortBy,
+    sort_descending: sortDescending,
+    include,
+    select,
+    remove,
+    start,
+    limit
+  };
+
+  Object.keys(queryParams).forEach(key => {
+    const value = queryParams[key];
+    if(value === undefined || (Array.isArray(value) && value.length === 0)) {
+      delete queryParams[key];
+    }
+  });
+
+  return this.utils.ResponseToJson(
+    httpClient.Request({
+      headers: { "Authorization": `Bearer ${token}` },
+      method: "GET",
+      path: path,
+      queryParams
+    })
+  );
+};

package/src/client/ContentManagement.js

@@ -25,6 +25,34 @@ const {
   ValidatePresence,
 } = require("../Validation");
 
+/* Validation for Fabric tags, groups and query fields */
+
+const ValidateTags = (tags) => {
+  if(!Array.isArray(tags)) {
+    throw Error("Tags must be an array");
+  }
+};
+
+// Group references are content object IDs. A library ID is also accepted, since a library
+// may act as a group (see the Fabric's "lib" unique group type).
+const ValidateGroups = (groups) => {
+  if(!Array.isArray(groups)) {
+    throw Error("Groups must be an array");
+  }
+
+  groups.forEach(groupId => {
+    if(typeof groupId !== "string" || !(groupId.startsWith("iq__") || groupId.startsWith("ilib"))) {
+      throw Error(`Invalid group ID: ${groupId}`);
+    }
+  });
+};
+
+const ValidateQueryFields = (queryFields) => {
+  if(typeof queryFields !== "object" || queryFields === null || Array.isArray(queryFields)) {
+    throw Error("Query fields must be an object");
+  }
+};
+
 exports.SetVisibility = async function({id, visibility}) {
   this.Log(`Setting visibility ${visibility} on ${id}`);
 
@@ -536,14 +564,18 @@ exports.RemoveLibraryContentType = async function({libraryId, typeId, typeName,
  * @namedParams
  * @param {string} libraryId - ID of the library
  * @param {string=} objectId - ID of the object (if contract already exists)
- * @param {Object=} options -
- * type: Version hash of the content type to associate with the object
- *
- * meta: Metadata to use for the new object
- *
- * noEncryptionConk: Set to true to prevent creation of an encryption conk for the object
- *
- * createKMSConk: Set to true to create a KMS conk for object (usually for sharing a playable object) (incompatible with noEncryptionConk: true)
+ * @param {Object=} options - Additional object creation options
+ * @param {string=} options.type - Version hash of the content type to associate with the object
+ * @param {Object=} options.meta - Metadata to use for the new object
+ * @param {string=} options.copy_from - Version hash of an existing object version to copy
+ * @param {string=} options.objectType - System-level object type, e.g. "cgroup" for a content group. May only be
+ * specified when creating a new object - the Fabric rejects an object type change on a new version of an existing object
+ * @param {Array<string>=} options.tags - Fabric tags to associate with the object
+ * @param {Array<string>=} options.groups - IDs of the content groups to add the object to. These categorize content and
+ * are distinct from the access groups that grant permissions
+ * @param {Object<string, string>=} options.queryFields - Unencrypted, indexed query fields to associate with the object
+ * @param {boolean=} options.noEncryptionConk - Set to true to prevent creation of an encryption conk for the object
+ * @param {boolean=} options.createKMSConk - Set to true to create a KMS conk for object (usually for sharing a playable object) (incompatible with noEncryptionConk: true)
  *
  * @returns {Promise<Object>} - Response containing the object ID and write token of the draft, as well as the url of the node that created the write token.
  */
@@ -555,6 +587,10 @@ exports.CreateContentObject = async function({libraryId, objectId, options={}})
 
   if(options.noEncryptionConk && options.createKMSConk) throw new Error("Incompatible options: noEncryptionConk and createKMSConk both set to true");
 
+  if(options.tags !== undefined) { ValidateTags(options.tags); }
+  if(options.groups !== undefined) { ValidateGroups(options.groups); }
+  if(options.queryFields !== undefined) { ValidateQueryFields(options.queryFields); }
+
   // Look up content type, if specified
   let typeId;
   if(options.type) {
@@ -613,7 +649,11 @@ exports.CreateContentObject = async function({libraryId, objectId, options={}})
     body: {      // filter out options not recognized by server (noEncryptionConk, createKMSConk)
       type: options.type,
       meta: options.meta,
-      copy_from: options.copy_from
+      copy_from: options.copy_from,
+      object_type: options.objectType,
+      tags: options.tags,
+      groups: options.groups,
+      query_fields: options.queryFields
     }
   });
 
@@ -1621,3 +1661,320 @@ exports.DeleteWriteToken = async function({writeToken}) {
 
   await this.HttpClient.ClearWriteToken({writeToken});
 };
+
+/* Content group creation, modification, deletion */
+
+/**
+ * Create content tags
+ *
+ * @methodGroup Content Groups
+ * @namedParams
+ * @param {string} libraryId - ID of the library
+ * @param {string} writeToken - Write token of the draft
+ * @param {Array<string>} tags - List of tags
+ *
+ * @returns {Promise<Array<string>>} - The tags on the object after the update
+ */
+exports.AddContentObjectTags = async function({libraryId, writeToken, tags}) {
+  ValidateLibrary(libraryId);
+  ValidateWriteToken(writeToken);
+  ValidatePresence("tags", tags);
+
+  const path = UrlJoin("qlibs", libraryId, "q", writeToken, "tags");
+  const objectId = this.utils.DecodeWriteToken(writeToken).objectId;
+
+  this.Log(`Adding tags: ${tags.join(", ")}`);
+
+  return this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true}),
+    method: "POST",
+    path: path,
+    body: tags,
+    allowFailover: false
+  });
+};
+
+/**
+ * Update content tags, replacing any existing tags
+ *
+ * @methodGroup Content Groups
+ * @namedParams
+ * @param {string} libraryId - ID of the library
+ * @param {string} writeToken - Write token of the draft
+ * @param {Array<string>} tags - Tags the object should have. Must be given explicitly - pass an empty
+ * array to remove all tags
+ *
+ * @returns {Promise<Array<string>>} - The tags on the object after the update
+ */
+exports.SetContentObjectTags = async function({libraryId, writeToken, tags}) {
+  ValidateLibrary(libraryId);
+  ValidateWriteToken(writeToken);
+  ValidateTags(tags);
+
+  const path = UrlJoin("qlibs", libraryId, "q", writeToken, "tags");
+  const objectId = this.utils.DecodeWriteToken(writeToken).objectId;
+
+  this.Log(`Updating tags: ${Array.isArray(tags) ? tags.join(", ") : tags}`);
+
+  return this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true}),
+    method: "PUT",
+    path: path,
+    body: tags,
+    allowFailover: false
+  });
+};
+
+/**
+ * Remove the given tags from a content object
+ *
+ * @methodGroup Content Groups
+ * @namedParams
+ * @param {string} libraryId - ID of the library
+ * @param {string} writeToken - Write token of the draft
+ * @param {Array<string>} tags - List of tags
+ *
+ * @returns {Promise<Array<string>>} - The tags on the object after the update
+ */
+exports.RemoveContentObjectTags = async function({libraryId, writeToken, tags=[]}) {
+  ValidateLibrary(libraryId);
+  ValidateWriteToken(writeToken);
+  ValidatePresence("tags", tags);
+
+  const path = UrlJoin("qlibs", libraryId, "q", writeToken, "tags");
+  const objectId = this.utils.DecodeWriteToken(writeToken).objectId;
+
+  this.Log(`Removing tags: ${tags.join(", ")}`);
+
+  return this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true}),
+    method: "DELETE",
+    path: path,
+    body: tags,
+    allowFailover: false
+  });
+};
+
+/**
+ * Create content query fields
+ *
+ * @methodGroup Content Groups
+ * @namedParams
+ * @param {string} libraryId - ID of the library
+ * @param {string} writeToken - Write token of the draft
+ * @param {Object} queryFields - Query fields defined by key/value pairs for each field
+ *
+ * @returns {Promise<Object<string, string>>} - The query fields on the object after the update
+ */
+exports.AddContentObjectQueryFields = async function({libraryId, writeToken, queryFields}) {
+  ValidateLibrary(libraryId);
+  ValidateWriteToken(writeToken);
+  ValidatePresence("queryFields", queryFields);
+
+  const path = UrlJoin("qlibs", libraryId, "q", writeToken, "query_fields");
+  const objectId = this.utils.DecodeWriteToken(writeToken).objectId;
+
+  return this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true}),
+    method: "POST",
+    path: path,
+    body: queryFields,
+    allowFailover: false
+  });
+};
+
+/**
+ * Replace existing content query fields
+ *
+ * @methodGroup Content Groups
+ * @namedParams
+ * @param {string} libraryId - ID of the library
+ * @param {string} writeToken - Write token of the draft
+ * @param {Object<string, string>} queryFields - Query fields as key/value pairs. Must be given explicitly -
+ * pass an empty object to remove all fields
+ *
+ * @returns {Promise<Object<string, string>>} - The query fields on the object after the update
+ */
+exports.SetContentObjectQueryFields = async function({libraryId, writeToken, queryFields}) {
+  ValidateLibrary(libraryId);
+  ValidateWriteToken(writeToken);
+  ValidateQueryFields(queryFields);
+
+  const path = UrlJoin("qlibs", libraryId, "q", writeToken, "query_fields");
+  const objectId = this.utils.DecodeWriteToken(writeToken).objectId;
+
+  return this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true}),
+    method: "PUT",
+    path: path,
+    body: queryFields,
+    allowFailover: false
+  });
+};
+
+/**
+ * Remove the given query fields from a content object
+ *
+ * @methodGroup Content Groups
+ * @namedParams
+ * @param {string} libraryId - ID of the library
+ * @param {string} writeToken - Write token of the draft
+ * @param {Array<string>} fieldNames - Names of the query fields to remove
+ *
+ * @returns {Promise<Object<string, string>>} - The query fields on the object after the update
+ */
+exports.RemoveContentObjectQueryFields = async function({libraryId, writeToken, fieldNames=[]}) {
+  ValidateLibrary(libraryId);
+  ValidateWriteToken(writeToken);
+  ValidatePresence("fieldNames", fieldNames);
+
+  const path = UrlJoin("qlibs", libraryId, "q", writeToken, "query_fields");
+  const objectId = this.utils.DecodeWriteToken(writeToken).objectId;
+
+  this.Log(`Removing query fields: ${fieldNames.join(", ")}`);
+
+  return this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true}),
+    method: "DELETE",
+    path: path,
+    body: fieldNames,
+    allowFailover: false
+  });
+};
+
+/**
+ * Create a content group - a content object that other content objects can be associated with in order to
+ * categorize them. Content groups are distinct from the access groups that grant permissions.
+ *
+ * The group is left as a draft; finalize it before adding content objects to it.
+ *
+ * @methodGroup Content Groups
+ * @namedParams
+ * @param {string} libraryId - ID of the library
+ * @param {string=} name - Internal content management name of the group
+ * @param {string=} displayTitle - Public-facing title of the group
+ * @param {Array<string>=} tags - Fabric tags to associate with the group
+ * @param {Object<string, string>=} queryFields - Unencrypted, indexed query fields to associate with the group,
+ * as key/value pairs
+ *
+ * @returns {Promise<Object>} - Response containing the object ID and write token of the draft
+ */
+exports.CreateContentGroup = async function({libraryId, name, displayTitle, tags, queryFields}) {
+  ValidateLibrary(libraryId);
+
+  const {objectId, writeToken} = await this.CreateContentObject({
+    libraryId,
+    options: {
+      objectType: "cgroup",
+      meta: {
+        public: {
+          name,
+          asset_metadata: {
+            display_title: displayTitle
+          }
+        }
+      },
+      tags,
+      queryFields
+    }
+  });
+
+  this.Log(`Created content group: ${objectId}`);
+
+  return {
+    objectId,
+    writeToken
+  };
+};
+
+/**
+ * Add a content object to the given content groups. Groups the object already belongs to are retained.
+ *
+ * @methodGroup Content Groups
+ * @namedParams
+ * @param {string} libraryId - ID of the library
+ * @param {string} writeToken - Write token of the draft
+ * @param {Array<string>} groups - IDs of the content groups to add the object to. An empty array is a no-op
+ *
+ * @returns {Promise<Array<string>>} - The groups the object belongs to after the update. Order is not preserved
+ */
+exports.AddContentObjectGroups = async function({libraryId, writeToken, groups=[]}) {
+  ValidateLibrary(libraryId);
+  ValidateWriteToken(writeToken);
+  ValidateGroups(groups);
+
+  const path = UrlJoin("qlibs", libraryId, "q", writeToken, "groups");
+  const objectId = this.utils.DecodeWriteToken(writeToken).objectId;
+
+  this.Log(`Adding groups: ${groups.join(", ")}`);
+
+  return this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true}),
+    method: "POST",
+    path: path,
+    body: groups,
+    allowFailover: false
+  });
+};
+
+/**
+ * Set the content groups a content object belongs to, replacing any existing groups.
+ *
+ * @methodGroup Content Groups
+ * @namedParams
+ * @param {string} libraryId - ID of the library
+ * @param {string} writeToken - Write token of the draft
+ * @param {Array<string>} groups - IDs of the content groups the object should belong to. Must be given
+ * explicitly - pass an empty array to remove the object from all groups
+ *
+ * @returns {Promise<Array<string>>} - The groups the object belongs to after the update. Order is not preserved
+ */
+exports.SetContentObjectGroups = async function({libraryId, writeToken, groups}) {
+  ValidateLibrary(libraryId);
+  ValidateWriteToken(writeToken);
+  ValidateGroups(groups);
+
+  const path = UrlJoin("qlibs", libraryId, "q", writeToken, "groups");
+  const objectId = this.utils.DecodeWriteToken(writeToken).objectId;
+
+  this.Log(`Setting groups: ${groups.join(", ")}`);
+
+  return this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true}),
+    method: "PUT",
+    path: path,
+    body: groups,
+    allowFailover: false
+  });
+};
+
+/**
+ * Remove a content object from the given content groups. Groups not listed are retained, and
+ * removing a group the object does not belong to is a no-op.
+ *
+ * @methodGroup Content Groups
+ * @namedParams
+ * @param {string} libraryId - ID of the library
+ * @param {string} writeToken - Write token of the draft
+ * @param {Array<string>} groups - IDs of the content groups to remove the object from. An empty array is a no-op
+ *
+ * @returns {Promise<Array<string>>} - The groups the object belongs to after the update. Order is not preserved
+ */
+exports.RemoveContentObjectGroups = async function({libraryId, writeToken, groups=[]}) {
+  ValidateLibrary(libraryId);
+  ValidateWriteToken(writeToken);
+  ValidateGroups(groups);
+
+  const path = UrlJoin("qlibs", libraryId, "q", writeToken, "groups");
+  const objectId = this.utils.DecodeWriteToken(writeToken).objectId;
+
+  this.Log(`Removing groups: ${groups.join(", ")}`);
+
+  return this.HttpClient.RequestJsonBody({
+    headers: await this.authClient.AuthorizationHeader({libraryId, objectId, update: true}),
+    method: "DELETE",
+    path: path,
+    body: groups,
+    allowFailover: false
+  });
+};

package/src/client/LiveStream.js

@@ -4215,6 +4215,43 @@ exports.OutputsReset = async function({libraryId, objectId, outputId}) {
   }
 };
 
+/**
+ * Manually switch a live output's active input hop (e.g. primary <-> failover).
+ *
+ * @methodGroup Live Stream
+ * @namedParams
+ * @param {string=} libraryId - Library ID of the output settings object. If not provided, it will be retrieved automatically.
+ * @param {string} objectId - Object ID of the output settings object
+ * @param {string} outputId - ID of the output to switch
+ * @param {number=} hop=0 - Target hop index (0 = primary input, 1 = first failover input)
+ *
+ * @returns {Promise<Object>} - Response from the hop call
+ */
+exports.OutputsHop = async function({libraryId, objectId, outputId, hop=0}) {
+  ValidateObject(objectId);
+  ValidatePresence("outputId", outputId);
+
+  if(!libraryId) {
+    libraryId = await this.ContentObjectLibraryId({objectId});
+  }
+
+  // Route to a live egress node, then to the specific output's node
+  const {restore} = await RouteToLiveEgress({client: this});
+  await RouteToOutputNode({client: this, libraryId, objectId, outputId});
+
+  try {
+    return await this.CallBitcodeMethod({
+      libraryId,
+      objectId,
+      method: UrlJoin("live", "outputs", outputId, "ctrl", "hop"),
+      queryParams: {hop},
+      constant: false
+    });
+  } finally {
+    restore();
+  }
+};
+
 /**
  * Delete a live output.
  *

package/testScripts/Test.js

@@ -11,7 +11,7 @@ const Test = async () => {
 
   try {
     const client = await ElvClient.FromNetworkName({
-      networkName: "demo"
+      networkName: "main"
     });
 
     const wallet = client.GenerateWallet();
@@ -21,7 +21,19 @@ const Test = async () => {
 
     client.SetSigner({signer});
 
-    console.log(await client.ContentLibraries());
+    const configUrl = new URL(await client.ConfigUrl());
+    configUrl.pathname = "/config";
+    // if(geo) { configUrl.searchParams.set("elvgeo", geo); }   // optional region scoping
+
+    const fabricInfo = await (await fetch(configUrl.toString())).json();
+    // fabricInfo.network.services.*  e.g. live_egress, ethereum, authority, etc.
+    const liveEgressUrls = fabricInfo?.network?.services?.live_egress;
+    console.log('fabricINfo', fabricInfo.network?.services?.tenant_query)
+
+    // tenant_query nodes are now wired into the client and used automatically by TenantContent:
+    console.log('client tenantQueryURIs', client.Nodes().tenantQueryURIs)
+    // const result = await client.TenantContent({limit: 5});
+    // console.log(JSON.stringify(result, null, 2));
   } catch(error) {
     console.error(error);
     console.error(JSON.stringify(error, null, 2));

package/utilities/ObjectInfo.js

@@ -0,0 +1,99 @@
+// List all info for an object: details, profile, tags, content groups and query fields
+
+const R = require("ramda");
+
+const {NewOpt} = require("./lib/options");
+
+const Utility = require("./lib/Utility");
+
+const Client = require("./lib/concerns/Client");
+const ExistObjOrVer = require("./lib/concerns/ExistObjOrVer");
+const ArgOutfile = require("./lib/concerns/ArgOutfile");
+
+// Sections that come from the Fabric's tags/groups/query_fields endpoints. A node that does not
+// serve them should not prevent the rest of the info from being reported.
+const FABRIC_PROPERTIES = [
+  {key: "tags", method: "ContentObjectTags", empty: []},
+  {key: "groups", method: "ContentObjectGroups", empty: []},
+  {key: "query_fields", method: "ContentObjectQueryFields", empty: {}}
+];
+
+class ObjectInfo extends Utility {
+  blueprint() {
+    return {
+      concerns: [Client, ExistObjOrVer, ArgOutfile],
+      options: [
+        NewOpt("details", {
+          descTemplate: "Include object details (id, hash, type, size stats). Default: true",
+          default: true,
+          type: "boolean"
+        }),
+        NewOpt("profile", {
+          descTemplate: "Include the content profile (owner, visibility, status code, KMS, tenant). Default: true",
+          default: true,
+          type: "boolean"
+        }),
+        NewOpt("properties", {
+          descTemplate: "Include Fabric tags, content groups and query fields. Default: true",
+          default: true,
+          type: "boolean"
+        })
+      ]
+    };
+  }
+
+  async body() {
+    const logger = this.logger;
+    const client = await this.concerns.Client.get();
+
+    const {libraryId, objectId, versionHash} = await this.concerns.ExistObjOrVer.argsProc();
+
+    const info = {
+      object_id: objectId,
+      version_hash: versionHash,
+      library_id: libraryId
+    };
+
+    if(this.args.details || this.args.profile) {
+      // ContentObject requests details and profile together
+      const contentObject = await client.ContentObject({objectId, versionHash});
+
+      if(this.args.profile) {
+        info.profile = contentObject.content_profile;
+      }
+
+      if(this.args.details) {
+        info.details = R.omit(["content_profile"], contentObject);
+      }
+    }
+
+    if(this.args.properties) {
+      for(const {key, method, empty} of FABRIC_PROPERTIES) {
+        try {
+          info[key] = await client[method]({objectId, versionHash}) || empty;
+        } catch(error) {
+          logger.warn(`Unable to retrieve ${key}: ${error.message || error}`);
+          info[key] = {error: error.message || String(error)};
+        }
+      }
+    }
+
+    logger.data("object_info", info);
+
+    if(this.args.outfile) {
+      this.concerns.ArgOutfile.writeJson({obj: info});
+    } else {
+      logger.logObject(info);
+    }
+  }
+
+  header() {
+    return `Get info for object ${this.args.versionHash || this.args.objectId}`;
+  }
+}
+
+if(require.main === module) {
+  Utility.cmdLineInvoke(ObjectInfo);
+} else {
+  module.exports = ObjectInfo;
+}

package/utilities/TenantContent.js

@@ -0,0 +1,136 @@
+// Query the published content of a tenant using the Fabric content index
+
+const {NewOpt} = require("./lib/options");
+
+const Utility = require("./lib/Utility");
+
+const Client = require("./lib/concerns/Client");
+const ArgOutfile = require("./lib/concerns/ArgOutfile");
+
+// Joined into a single cell so the table keeps a stable, readable width
+const Join = value => Array.isArray(value) ? value.join(", ") : value;
+
+const FlattenMap = obj =>
+  Object.entries(obj || {}).map(([k, v]) => `${k}=${v}`).join(", ");
+
+class TenantContent extends Utility {
+  blueprint() {
+    return {
+      concerns: [Client, ArgOutfile],
+      options: [
+        NewOpt("tenantId", {
+          descTemplate: "Tenant to query (should start with 'iten'). Defaults to the tenant of the current user",
+          type: "string"
+        }),
+        NewOpt("filter", {
+          descTemplate: "Filter expression(s) '<field>:<comparator>:<value>', combined with AND. " +
+            "Reserved fields: tag, group, unique_group.id, unique_group.type, lib/library (eq only), " +
+            "created_block_time. Any other name is a query field - prefix with 'qf.' to disambiguate. " +
+            "Comparators: co (or ::), nc, eq, ne, lt, le, gt, ge. " +
+            "e.g. --filter 'tag:eq:elv:media:live_stream' 'qf.date:ge:2026-09-01'",
+          string: true,
+          type: "array"
+        }),
+        NewOpt("sortBy", {
+          descTemplate: "Query field name to sort by (not a metadata path). Only one may be given. " +
+            "Also restricts results to objects that have the field",
+          type: "string"
+        }),
+        NewOpt("sortDescending", {
+          descTemplate: "Sort in descending order",
+          type: "boolean"
+        }),
+        NewOpt("include", {
+          descTemplate: "Index data to return with each result: tags, groups, uniquegroups, fields, " +
+            "type, name, all, none. Defaults to query fields only",
+          string: true,
+          type: "array"
+        }),
+        NewOpt("select", {
+          descTemplate: "Metadata subtree path(s) to include in each result. If omitted, no metadata is retrieved",
+          string: true,
+          type: "array"
+        }),
+        NewOpt("remove", {
+          descTemplate: "Metadata subtree path(s) to omit from each result. Only has an effect with --select",
+          string: true,
+          type: "array"
+        }),
+        NewOpt("start", {
+          descTemplate: "Index of the first object to retrieve",
+          type: "number"
+        }),
+        NewOpt("limit", {
+          descTemplate: "Maximum number of objects to return. Fabric default 100, capped at 998",
+          type: "number"
+        })
+      ]
+    };
+  }
+
+  async body() {
+    const logger = this.logger;
+    const client = await this.concerns.Client.get();
+
+    const {
+      tenantId, filter, sortBy, sortDescending, include, select, remove, start, limit
+    } = this.args;
+
+    const response = await client.TenantContent({
+      tenantId,
+      filter,
+      sortBy,
+      sortDescending,
+      include,
+      select,
+      remove,
+      start,
+      limit
+    });
+
+    const versions = response.versions || [];
+
+    logger.data("versions", versions);
+    logger.data("paging", response.paging);
+    logger.log(`Found ${versions.length} object(s)`);
+
+    if(this.args.outfile) {
+      this.concerns.ArgOutfile.writeJson({obj: response});
+      return;
+    }
+
+    // Only show columns that at least one result actually has
+    const rows = versions.map(v => {
+      const row = {object_id: v.id, hash: v.hash};
+      if(v.name !== undefined) row.name = v.name;
+      if(v.last_modified_at !== undefined) row.last_modified_at = v.last_modified_at;
+      if(v.query_fields !== undefined) row.query_fields = FlattenMap(v.query_fields);
+      if(v.tags !== undefined) row.tags = Join(v.tags);
+      if(v.groups !== undefined) row.groups = Join(v.groups);
+      if(v.unique_groups !== undefined) row.unique_groups = FlattenMap(v.unique_groups);
+      if(v.error) row.error = v.error;
+      return row;
+    });
+
+    if(rows.length > 0) {
+      logger.logTable({list: rows});
+    } else {
+      logger.warn("No content matched the query.");
+    }
+
+    if(response.paging) {
+      const {items, limit: pageLimit, current} = response.paging;
+      logger.log(`Showing ${current || 0}-${(current || 0) + versions.length} of ${items} (page size ${pageLimit})`);
+    }
+  }
+
+  header() {
+    return `Query content for tenant ${this.args.tenantId || "of current user"}`;
+  }
+}
+
+if(require.main === module) {
+  Utility.cmdLineInvoke(TenantContent);
+} else {
+  module.exports = TenantContent;
+}