contree-client 0.1.0

package/lib/client.js

@@ -0,0 +1,786 @@
+// Generated by codegen from the OpenAPI spec - do not edit.
+
+import {
+  ContreeAPIError,
+  ContreeError,
+  NotFoundError,
+  SSEStreamError,
+} from "./errors.js";
+import { AUTH_TYPE_IAM, ProfileError, resolveProfile } from "./profiles.js";
+import {
+  IS_NODE,
+  SSEParser,
+  TIGHT_LOOP_FLOOR,
+  UA_PLATFORM,
+  UA_PRODUCT,
+  UA_RUNTIME,
+  decodeFramePayload,
+  encodeQuery,
+  errorForResponse,
+  monotonic,
+  retryAfterDelay,
+  retryDelays,
+  sha256,
+  isUuid,
+  sleep,
+} from "./runtime.js";
+import { DEFAULT_BASE_URL } from "./specInfo.js";
+import { OperationEvent, isTerminalStatus } from "./models.js";
+import * as operations from "./operations.js";
+
+/** Contree API client on top of the platform fetch.
+ *
+ * fetch pools keepalive connections and decodes gzip on its own, so
+ * unlike the Python adapters there is exactly one transport. Pass a
+ * custom `fetch` implementation (undici dispatcher wrappers, MSW,
+ * ...) via the constructor options to customize it.
+ */
+export class ContreeClient {
+  constructor(
+    token,
+    {
+      baseUrl = DEFAULT_BASE_URL,
+      project = null,
+      timeout = 300,
+      retry = null,
+      identity = null,
+      fetch: fetchImpl = null,
+    } = {},
+  ) {
+    // a typo like "htps://" must not silently degrade somewhere else
+    const parsed = new URL(baseUrl);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new RangeError(
+        `unsupported baseUrl scheme ${parsed.protocol} in ${baseUrl}: use http:// or https://`,
+      );
+    }
+    this.token = token;
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.project = project;
+    this.timeout = timeout;
+    this.retry = retry;
+    this.identity = identity;
+    this._fetch = fetchImpl ?? globalThis.fetch.bind(globalThis);
+  }
+
+  /** Create a client from a saved Contree profile (Node). */
+  static async fromProfile(
+    profile = null,
+    { configPath = null, ...options } = {},
+  ) {
+    const resolved =
+      profile !== null && typeof profile === "object"
+        ? profile
+        : await resolveProfile(profile, { path: configPath });
+    if (!resolved.token || !resolved.token.trim()) {
+      throw new ProfileError(
+        `profile ${JSON.stringify(resolved.name)} has no token`,
+      );
+    }
+    if (!resolved.url && resolved.authType !== AUTH_TYPE_IAM) {
+      throw new ProfileError(
+        `profile ${JSON.stringify(resolved.name)} has no URL`,
+      );
+    }
+    return new this(resolved.token, {
+      baseUrl: resolved.url || DEFAULT_BASE_URL,
+      project: resolved.project ?? null,
+      ...options,
+    });
+  }
+
+  /** Compose the User-Agent from the product tokens; the caller's
+   * `identity` leads. Browsers forbid sending the header, so it is
+   * only attached in Node. */
+  userAgent() {
+    return [this.identity, UA_PRODUCT, UA_RUNTIME, UA_PLATFORM]
+      .filter(Boolean)
+      .join(" ");
+  }
+
+  buildUrl(spec) {
+    let url = `${this.baseUrl}/v1${spec.path}`;
+    if (spec.query && Object.keys(spec.query).length) {
+      url = `${url}?${encodeQuery(spec.query)}`;
+    }
+    return url;
+  }
+
+  buildHeaders(spec) {
+    const headers = { Authorization: `Bearer ${this.token}` };
+    if (this.project !== null) {
+      headers["Project"] = this.project;
+    }
+    if (spec.contentType) {
+      headers["Content-Type"] = spec.contentType;
+    }
+    if (spec.accept) {
+      headers["Accept"] = spec.accept;
+    }
+    Object.assign(headers, spec.headers ?? {});
+    if (IS_NODE && !("User-Agent" in headers)) {
+      headers["User-Agent"] = this.userAgent();
+    }
+    return headers;
+  }
+
+  _fetchOptions(spec, signal) {
+    const options = {
+      method: spec.method,
+      headers: this.buildHeaders(spec),
+      redirect: spec.redirect ?? "manual",
+      signal,
+    };
+    if (spec.body !== undefined && spec.body !== null) {
+      options.body = spec.body;
+      if (
+        typeof ReadableStream !== "undefined" &&
+        spec.body instanceof ReadableStream
+      ) {
+        options.duplex = "half";
+      }
+    }
+    return options;
+  }
+
+  /** Execute the request and return the buffered response. */
+  async request(spec) {
+    const controller = new AbortController();
+    // an explicit timer, not AbortSignal.timeout(): Node unrefs that
+    // timer, so it can never fire when nothing else keeps the event
+    // loop alive (custom fetch transports, for one)
+    const timer =
+      this.timeout !== null
+        ? setTimeout(
+            () =>
+              controller.abort(
+                new DOMException("request timed out", "TimeoutError"),
+              ),
+            this.timeout * 1000,
+          )
+        : null;
+    try {
+      const response = await this._fetch(
+        this.buildUrl(spec),
+        this._fetchOptions(spec, controller.signal),
+      );
+      const body = new Uint8Array(await response.arrayBuffer());
+      const headers = {};
+      response.headers.forEach((value, key) => {
+        headers[key.toLowerCase()] = value;
+      });
+      return { status: response.status, headers, body, url: response.url };
+    } finally {
+      if (timer !== null) {
+        clearTimeout(timer);
+      }
+    }
+  }
+
+  /** fetch reports network failures as TypeError; timeouts abort. */
+  _transportRetryable(error) {
+    return error instanceof TypeError;
+  }
+
+  _transportNonretryable(error) {
+    return (
+      error instanceof DOMException &&
+      (error.name === "AbortError" || error.name === "TimeoutError")
+    );
+  }
+
+  /** One transparent reconnect for a replayable idempotent request:
+   * fetch pools keep-alive sockets and cannot pre-check them the way
+   * the Python adapters do, so the first request on a socket the
+   * server already closed fails without ever reaching the server. */
+  async _reconnecting(spec) {
+    try {
+      return await this.request(spec);
+    } catch (error) {
+      if (
+        !spec.idempotent ||
+        (typeof ReadableStream !== "undefined" &&
+          spec.body instanceof ReadableStream) ||
+        !this._transportRetryable(error) ||
+        this._transportNonretryable(error)
+      ) {
+        throw error;
+      }
+      return await this.request(spec);
+    }
+  }
+
+  /** Execute a buffered request, retrying per the client policy. */
+  async call(spec) {
+    const policy = this.retry;
+    if (policy === null) {
+      return await this._reconnecting(spec);
+    }
+    if (!spec.idempotent && !policy.retryUnsafe) {
+      // a lost response after a non-idempotent request (POST) could
+      // mean a second execution server-side
+      return await this.request(spec);
+    }
+    if (
+      typeof ReadableStream !== "undefined" &&
+      spec.body instanceof ReadableStream
+    ) {
+      // a stream cannot be replayed: single attempt
+      return await this.request(spec);
+    }
+    const delays = retryDelays(policy.delays);
+    let attempts = 0;
+    for (;;) {
+      attempts += 1;
+      const exhausted =
+        policy.maxAttempts !== null && attempts >= policy.maxAttempts;
+      let response;
+      try {
+        response = await this.request(spec);
+      } catch (error) {
+        if (
+          !this._transportRetryable(error) ||
+          this._transportNonretryable(error) ||
+          exhausted
+        ) {
+          throw error;
+        }
+        await sleep(delays.next().value);
+        continue;
+      }
+      if (!policy.retryableStatus(response.status) || exhausted) {
+        return response;
+      }
+      const retryAfter = retryAfterDelay(response);
+      await sleep(retryAfter !== null ? retryAfter : delays.next().value);
+    }
+  }
+
+  /** Execute the request and yield response body chunks. */
+  async *stream(spec) {
+    const controller = new AbortController();
+    let timer = null;
+    const disarm = () => {
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    };
+    const abortIn = (seconds) => {
+      disarm();
+      if (seconds === null) {
+        return;
+      }
+      timer = setTimeout(
+        () =>
+          controller.abort(
+            new DOMException("stream read timed out", "TimeoutError"),
+          ),
+        Math.max(0, seconds) * 1000,
+      );
+    };
+    const sse = spec.accept === "text/event-stream";
+    const deadline = spec.deadline ?? null; // monotonic seconds
+    // the budget for the next transport wait: downloads use the
+    // client timeout (idle cap, re-armed per chunk); SSE is unbounded
+    // unless the caller set an absolute deadline - keepalive frames
+    // re-enter abortIn with a shrinking remainder, so the bound stays
+    // absolute no matter how often the server keeps the stream warm
+    const nextBudget = () => {
+      if (!sse) {
+        return this.timeout;
+      }
+      return deadline === null ? null : deadline - monotonic();
+    };
+    // the server may close a pooled keep-alive socket between
+    // requests and fetch exposes no pool to pre-check (the Python
+    // adapters validate pooled connections instead): a replayable
+    // connect that fails on the transport is retried per the client
+    // policy, and even with no policy it gets one transparent
+    // reconnect - the body has not been consumed yet, so it is safe
+    const replayable =
+      spec.idempotent &&
+      !(
+        typeof ReadableStream !== "undefined" &&
+        spec.body instanceof ReadableStream
+      );
+    const policy = replayable ? this.retry : null;
+    const maxAttempts =
+      policy !== null ? policy.maxAttempts : replayable ? 2 : 1;
+    const delays = policy === null ? null : retryDelays(policy.delays);
+    let attempts = 0;
+    let response;
+    for (;;) {
+      attempts += 1;
+      abortIn(this.timeout); // the connect phase always has a bound
+      try {
+        response = await this._fetch(
+          this.buildUrl(spec),
+          this._fetchOptions(spec, controller.signal),
+        );
+        break;
+      } catch (error) {
+        disarm();
+        if (
+          !this._transportRetryable(error) ||
+          this._transportNonretryable(error) ||
+          (maxAttempts !== null && attempts >= maxAttempts)
+        ) {
+          throw error;
+        }
+        await sleep(delays === null ? 0 : delays.next().value);
+      }
+    }
+    if (!(response.status >= 200 && response.status < 300)) {
+      // the error body is read under the same timer: a 500 with an
+      // endless body must not hang the caller
+      let body;
+      try {
+        body = new Uint8Array(await response.arrayBuffer());
+      } finally {
+        disarm();
+      }
+      const headers = {};
+      response.headers.forEach((value, key) => {
+        headers[key.toLowerCase()] = value;
+      });
+      throw errorForResponse({ status: response.status, headers, body });
+    }
+    disarm();
+    const reader = response.body.getReader();
+    try {
+      for (;;) {
+        abortIn(nextBudget());
+        const { done, value } = await reader.read();
+        // the timer covers only the transport wait, never the
+        // consumer's processing of the yielded chunk
+        disarm();
+        if (done) {
+          return;
+        }
+        yield value;
+      }
+    } finally {
+      disarm();
+      try {
+        await reader.cancel();
+      } catch {
+        // the stream is already gone; releasing is best-effort
+      }
+    }
+  }
+
+  async open() {}
+
+  async close() {}
+
+  /** Best-effort check that the operation reached a terminal state. */
+  async operationTerminal(operationId) {
+    let status;
+    try {
+      status = (await this.getOperationStatus(operationId)).status;
+    } catch (error) {
+      if (error instanceof ContreeError || this._transportRetryable(error)) {
+        return false;
+      }
+      throw error;
+    }
+    return status !== undefined && isTerminalStatus(status);
+  }
+
+  /** Wait until the operation finishes, driven by its event stream:
+   * follows the SSE log until `completion`, then fetches and returns
+   * the terminal OperationResponse. */
+  async waitOperation(operationId, { timeout = null } = {}) {
+    // eslint-disable-next-line no-unused-vars
+    for await (const event of this.followOperationEvents(operationId, {
+      timeout,
+    })) {
+      // draining the stream is the wait
+    }
+    return await this.getOperationStatus(operationId);
+  }
+
+  /** Stream operation events with transparent reconnection: network
+   * drops, in-band SSE error frames and retryable API statuses
+   * (410/425/5xx) reconnect from the last received event id; other
+   * API errors propagate. Ends after the `completion` event. */
+  async *followOperationEvents(
+    operationId,
+    { last_event_id = null, spid = null, since = null, timeout = null } = {},
+  ) {
+    let lastId = last_event_id;
+    const delays = retryDelays();
+    const deadline = timeout === null ? null : monotonic() + timeout;
+    const checkDeadline = () => {
+      if (deadline !== null && monotonic() >= deadline) {
+        throw new ContreeAPIError(
+          0,
+          `operation ${operationId} events did not complete within ${timeout}s`,
+        );
+      }
+    };
+    for (;;) {
+      checkDeadline();
+      const eventsBefore = lastId;
+      try {
+        for await (const event of this.iterOperationEvents(operationId, {
+          follow: true,
+          spid,
+          since,
+          last_event_id: lastId,
+          deadline,
+        })) {
+          lastId = event.id;
+          yield event;
+          if (event.type === "completion") {
+            return;
+          }
+          checkDeadline();
+        }
+      } catch (error) {
+        if (error instanceof SSEStreamError) {
+          if (error.lastEventId !== null) {
+            lastId = error.lastEventId;
+          }
+        } else if (error instanceof ContreeAPIError) {
+          const retryable =
+            error.status === 410 ||
+            error.status === 425 ||
+            (error.status >= 500 && error.status < 600);
+          if (!retryable) {
+            throw error;
+          }
+          if (await this.operationTerminal(operationId)) {
+            return;
+          }
+          let delay =
+            error.retryAfter !== null ? error.retryAfter : delays.next().value;
+          if (deadline !== null) {
+            // a Retry-After must not sleep past the caller's deadline
+            delay = Math.min(delay, Math.max(0, deadline - monotonic()));
+          }
+          await sleep(delay);
+          continue;
+        } else if (
+          !this._transportRetryable(error) ||
+          this._transportNonretryable(error)
+        ) {
+          throw error;
+        }
+      }
+      // the stream ended or broke without a completion frame: the
+      // retry must not outlive the operation itself
+      if (await this.operationTerminal(operationId)) {
+        return;
+      }
+      if (lastId === eventsBefore) {
+        await sleep(TIGHT_LOOP_FLOOR);
+      }
+    }
+  }
+
+  /** Resolve an image reference (UUID, `tag:NAME` or bare tag) to a UUID. */
+  async resolveImage(ref) {
+    if (ref.startsWith("tag:")) {
+      return await this.inspectFindImageByTag(ref.slice(4));
+    }
+    if (isUuid(ref)) {
+      return ref;
+    }
+    return await this.inspectFindImageByTag(ref);
+  }
+
+  /** Upload *content* unless the server already stores it (sha256
+   * dedup). A ReadableStream cannot be hashed and replayed, so
+   * without a caller-provided sha256 it uploads directly. */
+  async ensureFile(content, { sha256: digest = null } = {}) {
+    const resolved = digest !== null ? digest : await sha256(content);
+    if (resolved === null) {
+      return await this.uploadFile(content);
+    }
+    try {
+      return await this.getFile(resolved);
+    } catch (error) {
+      if (error instanceof NotFoundError) {
+        return await this.uploadFile(content);
+      }
+      throw error;
+    }
+  }
+
+  /** List publicly available images (GET /images) */
+  async listImages(options = {}) {
+    const spec = operations.buildListImages(options);
+    return operations.parseListImages(await this.call(spec));
+  }
+
+  /** Iterate over listImages() results across pages; offset
+   * pagination is transparent, breaking out stops fetching. */
+  async *iterImages(options = {}) {
+    const { page_size = 1000, limit = null, ...filters } = options;
+    if (!Number.isInteger(page_size) || page_size < 1 || page_size > 1000) {
+      throw new RangeError("page_size must be an integer between 1 and 1000");
+    }
+    if (limit !== null && (!Number.isInteger(limit) || limit < 0)) {
+      throw new RangeError("limit must be null or a non-negative integer");
+    }
+    let fetched = 0;
+    let offset = 0;
+    for (;;) {
+      const size =
+        limit === null ? page_size : Math.min(page_size, limit - fetched);
+      if (size <= 0) {
+        return;
+      }
+      const response = await this.listImages({
+        ...filters,
+        limit: size,
+        offset,
+      });
+      const page = response.images ?? [];
+      if (!page.length) {
+        return;
+      }
+      for (const item of page) {
+        yield item;
+        fetched += 1;
+        if (limit !== null && fetched >= limit) {
+          return;
+        }
+      }
+      if (page.length < size) {
+        return;
+      }
+      offset += page.length;
+    }
+  }
+
+  /** Remove tags from an image (DELETE /images/{imageUUID}/tag) */
+  async deleteImageTag(imageUuid, options = {}) {
+    const spec = operations.buildDeleteImageTag(imageUuid, options);
+    return operations.parseDeleteImageTag(await this.call(spec));
+  }
+
+  /** Add a tag to an image (PATCH /images/{imageUUID}/tag) */
+  async updateImageTag(imageUuid, tag) {
+    const spec = operations.buildUpdateImageTag(imageUuid, tag);
+    return operations.parseUpdateImageTag(await this.call(spec));
+  }
+
+  /** Import a container image from a registry (POST /images/import) */
+  async importImage(registry, options = {}) {
+    const spec = operations.buildImportImage(registry, options);
+    return operations.parseImportImage(await this.call(spec));
+  }
+
+  /** List uploaded files for the current namespace (GET /files) */
+  async listFiles(options = {}) {
+    const spec = operations.buildListFiles(options);
+    return operations.parseListFiles(await this.call(spec));
+  }
+
+  /** Iterate over listFiles() results across pages; offset
+   * pagination is transparent, breaking out stops fetching. */
+  async *iterFiles(options = {}) {
+    const { page_size = 1000, limit = null, ...filters } = options;
+    if (!Number.isInteger(page_size) || page_size < 1 || page_size > 1000) {
+      throw new RangeError("page_size must be an integer between 1 and 1000");
+    }
+    if (limit !== null && (!Number.isInteger(limit) || limit < 0)) {
+      throw new RangeError("limit must be null or a non-negative integer");
+    }
+    let fetched = 0;
+    let offset = 0;
+    for (;;) {
+      const size =
+        limit === null ? page_size : Math.min(page_size, limit - fetched);
+      if (size <= 0) {
+        return;
+      }
+      const response = await this.listFiles({
+        ...filters,
+        limit: size,
+        offset,
+      });
+      const page = response.files ?? [];
+      if (!page.length) {
+        return;
+      }
+      for (const item of page) {
+        yield item;
+        fetched += 1;
+        if (limit !== null && fetched >= limit) {
+          return;
+        }
+      }
+      if (page.length < size) {
+        return;
+      }
+      offset += page.length;
+    }
+  }
+
+  /** Upload a file to the server. the body must be a file content. (POST /files) */
+  async uploadFile(content) {
+    const spec = operations.buildUploadFile(content);
+    return operations.parseUploadFile(await this.call(spec));
+  }
+
+  /** Get file info by SHA256 (GET /files/{sha256}) */
+  async getFile(sha256) {
+    const spec = operations.buildGetFile(sha256);
+    return operations.parseGetFile(await this.call(spec));
+  }
+
+  /** Check if a file exists for the current namespace (HEAD /files/{sha256}) */
+  async checkFileExists(sha256) {
+    const spec = operations.buildCheckFileExists(sha256);
+    return operations.parseCheckFileExists(await this.call(spec));
+  }
+
+  /** Spawn a new container instance (POST /instances) */
+  async spawnInstance(command, image, options = {}) {
+    const spec = operations.buildSpawnInstance(command, image, options);
+    return operations.parseSpawnInstance(await this.call(spec));
+  }
+
+  /** List operations (GET /operations) */
+  async listOperations(options = {}) {
+    const spec = operations.buildListOperations(options);
+    return operations.parseListOperations(await this.call(spec));
+  }
+
+  /** Iterate over listOperations() results across pages; offset
+   * pagination is transparent, breaking out stops fetching. */
+  async *iterOperations(options = {}) {
+    const { page_size = 1000, limit = null, ...filters } = options;
+    if (!Number.isInteger(page_size) || page_size < 1 || page_size > 1000) {
+      throw new RangeError("page_size must be an integer between 1 and 1000");
+    }
+    if (limit !== null && (!Number.isInteger(limit) || limit < 0)) {
+      throw new RangeError("limit must be null or a non-negative integer");
+    }
+    let fetched = 0;
+    let offset = 0;
+    for (;;) {
+      const size =
+        limit === null ? page_size : Math.min(page_size, limit - fetched);
+      if (size <= 0) {
+        return;
+      }
+      const response = await this.listOperations({
+        ...filters,
+        limit: size,
+        offset,
+      });
+      const page = response ?? [];
+      if (!page.length) {
+        return;
+      }
+      for (const item of page) {
+        yield item;
+        fetched += 1;
+        if (limit !== null && fetched >= limit) {
+          return;
+        }
+      }
+      if (page.length < size) {
+        return;
+      }
+      offset += page.length;
+    }
+  }
+
+  /** Get an operation status (GET /operations/{operationId}) */
+  async getOperationStatus(operationId, options = {}) {
+    const spec = operations.buildGetOperationStatus(operationId, options);
+    return operations.parseGetOperationStatus(await this.call(spec));
+  }
+
+  /** Cancel an operation (DELETE /operations/{operationId}) */
+  async cancelOperation(operationId) {
+    const spec = operations.buildCancelOperation(operationId);
+    return operations.parseCancelOperation(await this.call(spec));
+  }
+
+  /** Stream the operation event log via Server-Sent Events (GET /operations/{operationId}/events) */
+  async *iterOperationEvents(operationId, options = {}) {
+    const spec = operations.buildIterOperationEvents(operationId, options);
+    if (options.deadline != null) {
+      {
+        spec.deadline = options.deadline;
+      }
+    }
+    const parser = new SSEParser();
+    let lastSeen = options.last_event_id ?? null;
+    for await (const chunk of this.stream(spec)) {
+      for (const frame of parser.feed(chunk)) {
+        const payload = decodeFramePayload(frame, lastSeen);
+        // id-only frames advance the resume cursor even
+        // though they carry no payload
+        if (frame.id !== null) {
+          lastSeen = frame.id;
+        }
+        if (payload === null) {
+          continue;
+        }
+        yield OperationEvent.fromWire(payload);
+      }
+    }
+  }
+
+  /** Find image by tag (GET /inspect/) */
+  async inspectFindImageByTag(tag) {
+    const spec = operations.buildInspectFindImageByTag(tag);
+    return operations.parseInspectFindImageByTag(await this.call(spec));
+  }
+
+  /** Inspect an image (GET /inspect/{image_uuid}/) */
+  async inspectImage(imageUuid) {
+    const spec = operations.buildInspectImage(imageUuid);
+    return operations.parseInspectImage(await this.call(spec));
+  }
+
+  /** Download a file from image (GET /inspect/{image_uuid}/download) */
+  async inspectImageDownload(imageUuid, path) {
+    const spec = operations.buildInspectImageDownload(imageUuid, path);
+    return operations.parseInspectImageDownload(await this.call(spec));
+  }
+
+  /** Streaming variant of inspectImageDownload(). */
+  async *inspectImageDownloadStream(imageUuid, path) {
+    const spec = operations.buildInspectImageDownload(imageUuid, path);
+    yield* this.stream(spec);
+  }
+
+  /** Check if a file exists in image (HEAD /inspect/{image_uuid}/download) */
+  async checkImageFile(imageUuid, path) {
+    const spec = operations.buildCheckImageFile(imageUuid, path);
+    return operations.parseCheckImageFile(await this.call(spec));
+  }
+
+  /** Download a file or a directory from image as tar archive (GET /inspect/{image_uuid}/archive) */
+  async *inspectImageArchive(imageUuid, path) {
+    const spec = operations.buildInspectImageArchive(imageUuid, path);
+    yield* this.stream(spec);
+  }
+
+  /** Check if a path can be archived from image (HEAD /inspect/{image_uuid}/archive) */
+  async checkImageArchive(imageUuid, path) {
+    const spec = operations.buildCheckImageArchive(imageUuid, path);
+    return operations.parseCheckImageArchive(await this.call(spec));
+  }
+
+  /** List files in image (GET /inspect/{image_uuid}/list) */
+  async inspectImageList(imageUuid, path) {
+    const spec = operations.buildInspectImageList(imageUuid, path);
+    return operations.parseInspectImageList(await this.call(spec));
+  }
+
+  /** Get current token information (GET /whoami) */
+  async whoami() {
+    const spec = operations.buildWhoami();
+    return operations.parseWhoami(await this.call(spec));
+  }
+}