@cubist-labs/cubesigner-sdk 0.1.26 → 0.1.77

package/dist/src/session/cognito_manager.d.ts

@@ -0,0 +1,59 @@
+import { Client } from "../client";
+import { HasEnv, SessionManager } from "./session_manager";
+import { SessionStorage } from "./session_storage";
+/** JSON representation of our "management session" file format */
+export interface CognitoSessionObject {
+    /** The email address of the user */
+    email: string;
+    /** The ID token */
+    id_token: string;
+    /** The access token */
+    access_token: string;
+    /** The refresh token */
+    refresh_token: string;
+    /** The expiration time of the access token */
+    expiration: string;
+}
+export interface CognitoSessionInfo extends CognitoSessionObject, HasEnv {
+}
+/** Type of storage required for cognito (management) sessions */
+export type CognitoSessionStorage = SessionStorage<CognitoSessionInfo>;
+/** The session manager for cognito (management) sessions */
+export declare class CognitoSessionManager extends SessionManager<CognitoSessionInfo> {
+    #private;
+    /**
+     * @return {string} The current auth token.
+     * @internal
+     */
+    token(): Promise<string>;
+    /**
+     * Returns a client with the current session and refreshes the current
+     * session.
+     */
+    client(): Promise<Client>;
+    /** Revokes the session. */
+    revoke(): Promise<void>;
+    /**
+     * Returns whether it's time to refresh this token.
+     * @return {boolean} Whether it's time to refresh this token.
+     * @internal
+     */
+    isStale(): Promise<boolean>;
+    /**
+     * Refreshes the session and **UPDATES/MUTATES** self.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Loads an existing cognito (management) session from storage.
+     * @param {CognitoSessionStorage} storage The storage back end to use
+     * @return {Promise<SingerSession>} New token
+     */
+    static loadFromStorage(storage: CognitoSessionStorage): Promise<CognitoSessionManager>;
+    /**
+     * Constructor.
+     * @param {EnvInterface} env The environment of the session
+     * @param {string} token The current token of the session
+     * @param {CognitoSessionStorage} storage The storage back end to use
+     */
+    private constructor();
+}

package/dist/src/session/cognito_manager.js

@@ -0,0 +1,111 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _CognitoSessionManager_client;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CognitoSessionManager = void 0;
+const session_manager_1 = require("./session_manager");
+/** The session manager for cognito (management) sessions */
+class CognitoSessionManager extends session_manager_1.SessionManager {
+    /**
+     * @return {string} The current auth token.
+     * @internal
+     */
+    async token() {
+        const session = await this.storage.retrieve();
+        return session.id_token;
+    }
+    /**
+     * Returns a client with the current session and refreshes the current
+     * session.
+     */
+    async client() {
+        this.refreshIfNeeded();
+        return __classPrivateFieldGet(this, _CognitoSessionManager_client, "f");
+    }
+    /** Revokes the session. */
+    async revoke() {
+        const idp = require("@aws-sdk/client-cognito-identity-provider"); // eslint-disable-line @typescript-eslint/no-var-requires
+        const session = await this.storage.retrieve();
+        const client = new idp.CognitoIdentityProviderClient({
+            region: this.env.Region,
+            signer: { sign: async (request) => request }, // eslint-disable-line @typescript-eslint/no-explicit-any
+        });
+        const input = {
+            Token: session.refresh_token,
+            ClientId: this.env.ClientId,
+        };
+        await client.send(new idp.RevokeTokenCommand(input));
+    }
+    /**
+     * Returns whether it's time to refresh this token.
+     * @return {boolean} Whether it's time to refresh this token.
+     * @internal
+     */
+    async isStale() {
+        const session = await this.storage.retrieve();
+        return this.hasExpired(new Date(session.expiration).getTime());
+    }
+    /**
+     * Refreshes the session and **UPDATES/MUTATES** self.
+     */
+    async refresh() {
+        const idp = require("@aws-sdk/client-cognito-identity-provider"); // eslint-disable-line @typescript-eslint/no-var-requires
+        const session = await this.storage.retrieve();
+        const client = new idp.CognitoIdentityProviderClient({ region: this.env.Region });
+        const resp = await client.send(new idp.InitiateAuthCommand({
+            AuthFlow: "REFRESH_TOKEN_AUTH",
+            AuthParameters: {
+                REFRESH_TOKEN: session.refresh_token,
+            },
+            ClientId: this.env.ClientId,
+        }));
+        if (!resp.AuthenticationResult ||
+            !resp.AuthenticationResult.ExpiresIn ||
+            !resp.AuthenticationResult.IdToken) {
+            throw new Error("Refresh failed");
+        }
+        const expiresInMs = resp.AuthenticationResult.ExpiresIn * 1000;
+        const expiration = new Date(new Date().getTime() + expiresInMs).toISOString();
+        const idToken = resp.AuthenticationResult.IdToken;
+        await this.storage.save({
+            ...session,
+            id_token: idToken,
+            access_token: resp.AuthenticationResult.AccessToken,
+            expiration,
+        });
+        __classPrivateFieldSet(this, _CognitoSessionManager_client, this.createClient(idToken), "f");
+    }
+    /**
+     * Loads an existing cognito (management) session from storage.
+     * @param {CognitoSessionStorage} storage The storage back end to use
+     * @return {Promise<SingerSession>} New token
+     */
+    static async loadFromStorage(storage) {
+        const sessionInfo = await storage.retrieve();
+        return new CognitoSessionManager(sessionInfo.env["Dev-CubeSignerStack"], sessionInfo.id_token, storage);
+    }
+    /**
+     * Constructor.
+     * @param {EnvInterface} env The environment of the session
+     * @param {string} token The current token of the session
+     * @param {CognitoSessionStorage} storage The storage back end to use
+     */
+    constructor(env, token, storage) {
+        super(env, storage);
+        _CognitoSessionManager_client.set(this, void 0);
+        __classPrivateFieldSet(this, _CognitoSessionManager_client, this.createClient(token), "f");
+    }
+}
+exports.CognitoSessionManager = CognitoSessionManager;
+_CognitoSessionManager_client = new WeakMap();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cognito_manager.js","sourceRoot":"","sources":["../../../src/session/cognito_manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { Client } from \"../client\";\nimport { EnvInterface } from \"../env\";\nimport { HasEnv, SessionManager } from \"./session_manager\";\nimport { SessionStorage } from \"./session_storage\";\n\n/** JSON representation of our \"management session\" file format */\nexport interface CognitoSessionObject {\n  /** The email address of the user */\n  email: string;\n  /** The ID token */\n  id_token: string;\n  /** The access token */\n  access_token: string;\n  /** The refresh token */\n  refresh_token: string;\n  /** The expiration time of the access token */\n  expiration: string;\n}\n\nexport interface CognitoSessionInfo extends CognitoSessionObject, HasEnv {}\n\n/** Type of storage required for cognito (management) sessions */\nexport type CognitoSessionStorage = SessionStorage<CognitoSessionInfo>;\n\n/** The session manager for cognito (management) sessions */\nexport class CognitoSessionManager extends SessionManager<CognitoSessionInfo> {\n  #client: Client;\n\n  /**\n   * @return {string} The current auth token.\n   * @internal\n   */\n  async token(): Promise<string> {\n    const session = await this.storage.retrieve();\n    return session.id_token;\n  }\n\n  /**\n   * Returns a client with the current session and refreshes the current\n   * session.\n   */\n  async client(): Promise<Client> {\n    this.refreshIfNeeded();\n    return this.#client;\n  }\n\n  /** Revokes the session. */\n  async revoke(): Promise<void> {\n    const idp = require(\"@aws-sdk/client-cognito-identity-provider\"); // eslint-disable-line @typescript-eslint/no-var-requires\n    const session = await this.storage.retrieve();\n    const client = new idp.CognitoIdentityProviderClient({\n      region: this.env.Region,\n      signer: { sign: async (request: any) => request }, // eslint-disable-line @typescript-eslint/no-explicit-any\n    });\n    const input = {\n      Token: session.refresh_token,\n      ClientId: this.env.ClientId,\n    };\n    await client.send(new idp.RevokeTokenCommand(input));\n  }\n\n  /**\n   * Returns whether it's time to refresh this token.\n   * @return {boolean} Whether it's time to refresh this token.\n   * @internal\n   */\n  async isStale(): Promise<boolean> {\n    const session = await this.storage.retrieve();\n    return this.hasExpired(new Date(session.expiration).getTime());\n  }\n\n  /**\n   * Refreshes the session and **UPDATES/MUTATES** self.\n   */\n  async refresh(): Promise<void> {\n    const idp = require(\"@aws-sdk/client-cognito-identity-provider\"); // eslint-disable-line @typescript-eslint/no-var-requires\n    const session = await this.storage.retrieve();\n    const client = new idp.CognitoIdentityProviderClient({ region: this.env.Region });\n    const resp = await client.send(\n      new idp.InitiateAuthCommand({\n        AuthFlow: \"REFRESH_TOKEN_AUTH\",\n        AuthParameters: {\n          REFRESH_TOKEN: session.refresh_token,\n        },\n        ClientId: this.env.ClientId,\n      }),\n    );\n\n    if (\n      !resp.AuthenticationResult ||\n      !resp.AuthenticationResult.ExpiresIn ||\n      !resp.AuthenticationResult.IdToken\n    ) {\n      throw new Error(\"Refresh failed\");\n    }\n\n    const expiresInMs = resp.AuthenticationResult.ExpiresIn * 1000;\n    const expiration = new Date(new Date().getTime() + expiresInMs).toISOString();\n    const idToken = resp.AuthenticationResult.IdToken;\n\n    await this.storage.save(<CognitoSessionInfo>{\n      ...session,\n      id_token: idToken,\n      access_token: resp.AuthenticationResult.AccessToken,\n      expiration,\n    });\n    this.#client = this.createClient(idToken);\n  }\n\n  /**\n   * Loads an existing cognito (management) session from storage.\n   * @param {CognitoSessionStorage} storage The storage back end to use\n   * @return {Promise<SingerSession>} New token\n   */\n  static async loadFromStorage(storage: CognitoSessionStorage): Promise<CognitoSessionManager> {\n    const sessionInfo = await storage.retrieve();\n    return new CognitoSessionManager(\n      sessionInfo.env[\"Dev-CubeSignerStack\"],\n      sessionInfo.id_token,\n      storage,\n    );\n  }\n\n  /**\n   * Constructor.\n   * @param {EnvInterface} env The environment of the session\n   * @param {string} token The current token of the session\n   * @param {CognitoSessionStorage} storage The storage back end to use\n   */\n  private constructor(env: EnvInterface, token: string, storage: CognitoSessionStorage) {\n    super(env, storage);\n    this.#client = this.createClient(token);\n  }\n}\n"]}

package/dist/src/session/session_manager.d.ts

@@ -28,6 +28,19 @@ export declare abstract class SessionManager<U> {
      * @internal
      */
     refreshIfNeeded(): Promise<boolean>;
+    /**
+     * Automatically refreshes the session in the background.
+     * The default implementation refreshes (if needed) every minute.
+     * Base implementations can, instead use the token expirations timestamps
+     * to refresh less often. This is a simple wrapper around `setInterval`.
+     * @return {number} The interval ID of the refresh timer.
+     */
+    autoRefresh(): RefreshId;
+    /**
+     * Clears the auto refresh timer.
+     * @param {number} timer The timer ID to clear.
+     */
+    clearAutoRefresh(timer: RefreshId): void;
     /**
      * Constructor.
      * @param {EnvInterface} env The environment of the session
@@ -72,3 +85,5 @@ export interface HasEnv {
         ["Dev-CubeSignerStack"]: EnvInterface;
     };
 }
+/** Type of the refresh timer ID. */
+export type RefreshId = ReturnType<typeof setInterval>;

package/dist/src/session/session_manager.js

@@ -20,6 +20,25 @@ class SessionManager {
         }
         return false;
     }
+    /**
+     * Automatically refreshes the session in the background.
+     * The default implementation refreshes (if needed) every minute.
+     * Base implementations can, instead use the token expirations timestamps
+     * to refresh less often. This is a simple wrapper around `setInterval`.
+     * @return {number} The interval ID of the refresh timer.
+     */
+    autoRefresh() {
+        return setInterval(async () => {
+            await this.refreshIfNeeded();
+        }, 60 * 1000);
+    }
+    /**
+     * Clears the auto refresh timer.
+     * @param {number} timer The timer ID to clear.
+     */
+    clearAutoRefresh(timer) {
+        clearInterval(timer);
+    }
     /**
      * Constructor.
      * @param {EnvInterface} env The environment of the session
@@ -50,7 +69,7 @@ class SessionManager {
      * @return {boolean} True if the timestamp has expired
      */
     hasExpired(exp, buffer) {
-        return exp < new Date().getTime() / 1000 + (buffer || DEFAULT_EXPIRATION_BUFFER_SECS);
+        return exp < new Date().getTime() + (buffer || DEFAULT_EXPIRATION_BUFFER_SECS) * 1000;
     }
     /**
      * Throws an error that says that some feature is unsupported.
@@ -76,4 +95,4 @@ class OrgSessionManager extends SessionManager {
     }
 }
 exports.OrgSessionManager = OrgSessionManager;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/session/session_storage.js

@@ -73,4 +73,4 @@ class JsonFileSessionStorage {
 }
 exports.JsonFileSessionStorage = JsonFileSessionStorage;
 _JsonFileSessionStorage_filePath = new WeakMap();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Vzc2lvbl9zdG9yYWdlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Nlc3Npb24vc2Vzc2lvbl9zdG9yYWdlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDJCQUFvQztBQVdwQywyQ0FBMkM7QUFDM0MsTUFBYSxvQkFBb0I7SUFHL0I7Ozs7T0FJRztJQUNILEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBTztRQUNoQix1QkFBQSxJQUFJLDhCQUFTLElBQUksTUFBQSxDQUFDO0lBQ3BCLENBQUM7SUFFRDs7O09BR0c7SUFDSCxLQUFLLENBQUMsUUFBUTtRQUNaLElBQUksQ0FBQyx1QkFBQSxJQUFJLGtDQUFNLEVBQUU7WUFDZixNQUFNLElBQUksS0FBSyxDQUFDLDZCQUE2QixDQUFDLENBQUM7U0FDaEQ7UUFDRCxPQUFPLHVCQUFBLElBQUksa0NBQU0sQ0FBQztJQUNwQixDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsWUFBWSxJQUFRO1FBMUJwQiw2Q0FBVTtRQTJCUix1QkFBQSxJQUFJLDhCQUFTLElBQUksTUFBQSxDQUFDO0lBQ3BCLENBQUM7Q0FDRjtBQTlCRCxvREE4QkM7O0FBRUQsZ0RBQWdEO0FBQ2hELE1BQWEsc0JBQXNCO0lBR2pDOzs7O09BSUc7SUFDSCxLQUFLLENBQUMsSUFBSSxDQUFDLElBQU87UUFDaEIsTUFBTSxhQUFFLENBQUMsU0FBUyxDQUFDLHVCQUFBLElBQUksd0NBQVUsRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ3BFLENBQUM7SUFFRDs7O09BR0c7SUFDSCxLQUFLLENBQUMsUUFBUTtRQUNaLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxNQUFNLGFBQUUsQ0FBQyxRQUFRLENBQUMsdUJBQUEsSUFBSSx3Q0FBVSxFQUFFLE9BQU8sQ0FBQyxDQUFDLENBQUM7SUFDaEUsQ0FBQztJQUVEOzs7T0FHRztJQUNILFlBQVksUUFBZ0I7UUF2Qm5CLG1EQUFrQjtRQXdCekIsdUJBQUEsSUFBSSxvQ0FBYSxRQUFRLE1BQUEsQ0FBQztJQUM1QixDQUFDO0NBQ0Y7QUEzQkQsd0RBMkJDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgcHJvbWlzZXMgYXMgZnMgfSBmcm9tIFwiZnNcIjtcblxuLyoqIEludGVyZmFjZSBmb3Igc3RvcmluZyBzZXNzaW9ucy4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2Vzc2lvblN0b3JhZ2U8VT4ge1xuICAvKiogU3RvcmUgc2Vzc2lvbiBpbmZvcm1hdGlvbiAqL1xuICBzYXZlKGRhdGE6IFUpOiBQcm9taXNlPHZvaWQ+O1xuXG4gIC8qKiBSZXRyaWV2ZSBzZXNzaW9uIGluZm9ybWF0aW9uICovXG4gIHJldHJpZXZlKCk6IFByb21pc2U8VT47XG59XG5cbi8qKiBTdG9yZXMgc2Vzc2lvbiBpbmZvcm1hdGlvbiBpbiBtZW1vcnkgKi9cbmV4cG9ydCBjbGFzcyBNZW1vcnlTZXNzaW9uU3RvcmFnZTxVPiBpbXBsZW1lbnRzIFNlc3Npb25TdG9yYWdlPFU+IHtcbiAgI2RhdGE/OiBVO1xuXG4gIC8qKlxuICAgKiBTdG9yZSBzZXNzaW9uIGluZm9ybWF0aW9uLlxuICAgKiBAcGFyYW0ge1V9IGRhdGEgVGhlIHNlc3Npb24gaW5mb3JtYXRpb24gdG8gc3RvcmVcbiAgICogQHJldHVybiB7UHJvbWlzZTx2b2lkPn1cbiAgICovXG4gIGFzeW5jIHNhdmUoZGF0YTogVSk6IFByb21pc2U8dm9pZD4ge1xuICAgIHRoaXMuI2RhdGEgPSBkYXRhO1xuICB9XG5cbiAgLyoqXG4gICAqIFJldHJpZXZlIHNlc3Npb24gaW5mb3JtYXRpb24uXG4gICAqIEByZXR1cm4ge1Byb21pc2U8VT59IFRoZSBzZXNzaW9uIGluZm9ybWF0aW9uXG4gICAqL1xuICBhc3luYyByZXRyaWV2ZSgpOiBQcm9taXNlPFU+IHtcbiAgICBpZiAoIXRoaXMuI2RhdGEpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihcIk1pc3Npbmcgc2Vzc2lvbiBpbmZvcm1hdGlvblwiKTtcbiAgICB9XG4gICAgcmV0dXJuIHRoaXMuI2RhdGE7XG4gIH1cblxuICAvKipcbiAgICogQ29uc3RydWN0b3IuXG4gICAqIEBwYXJhbSB7VT99IGRhdGEgVGhlIGluaXRpYWwgZGF0YVxuICAgKi9cbiAgY29uc3RydWN0b3IoZGF0YT86IFUpIHtcbiAgICB0aGlzLiNkYXRhID0gZGF0YTtcbiAgfVxufVxuXG4vKiogU3RvcmVzIHNlc3Npb24gaW5mb3JtYXRpb24gaW4gYSBKU09OIGZpbGUgKi9cbmV4cG9ydCBjbGFzcyBKc29uRmlsZVNlc3Npb25TdG9yYWdlPFU+IGltcGxlbWVudHMgU2Vzc2lvblN0b3JhZ2U8VT4ge1xuICByZWFkb25seSAjZmlsZVBhdGg6IHN0cmluZztcblxuICAvKipcbiAgICogU3RvcmUgc2Vzc2lvbiBpbmZvcm1hdGlvbi5cbiAgICogQHBhcmFtIHtVfSBkYXRhIFRoZSBzZXNzaW9uIGluZm9ybWF0aW9uIHRvIHN0b3JlXG4gICAqIEByZXR1cm4ge1Byb21pc2U8dm9pZD59XG4gICAqL1xuICBhc3luYyBzYXZlKGRhdGE6IFUpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBhd2FpdCBmcy53cml0ZUZpbGUodGhpcy4jZmlsZVBhdGgsIEpTT04uc3RyaW5naWZ5KGRhdGEpLCBcInV0Zi04XCIpO1xuICB9XG5cbiAgLyoqXG4gICAqIFJldHJpZXZlIHNlc3Npb24gaW5mb3JtYXRpb24uXG4gICAqIEByZXR1cm4ge1Byb21pc2U8VT59IFRoZSBzZXNzaW9uIGluZm9ybWF0aW9uXG4gICAqL1xuICBhc3luYyByZXRyaWV2ZSgpOiBQcm9taXNlPFU+IHtcbiAgICByZXR1cm4gSlNPTi5wYXJzZShhd2FpdCBmcy5yZWFkRmlsZSh0aGlzLiNmaWxlUGF0aCwgXCJ1dGYtOFwiKSk7XG4gIH1cblxuICAvKipcbiAgICogQ29uc3RydWN0b3IuXG4gICAqIEBwYXJhbSB7c3RyaW5nfSBmaWxlUGF0aCBUaGUgZmlsZSBwYXRoIHRvIHVzZSBmb3Igc3RvcmFnZVxuICAgKi9cbiAgY29uc3RydWN0b3IoZmlsZVBhdGg6IHN0cmluZykge1xuICAgIHRoaXMuI2ZpbGVQYXRoID0gZmlsZVBhdGg7XG4gIH1cbn1cbiJdfQ==

package/dist/src/session/signer_session_manager.d.ts

@@ -1,8 +1,9 @@
-import { CubeSigner } from "..";
+import { CubeSigner, EnvInterface } from "..";
 import { components, paths, Client } from "../client";
 import { HasEnv, OrgSessionManager } from "./session_manager";
 import { SessionStorage } from "./session_storage";
 export type ClientSessionInfo = components["schemas"]["ClientSessionInfo"];
+export type NewSessionResponse = components["schemas"]["NewSessionResponse"];
 export type CreateSignerSessionRequest = paths["/v0/org/{org_id}/roles/{role_id}/tokens"]["post"]["requestBody"]["content"]["application/json"];
 export type RefreshSignerSessionRequest = paths["/v1/org/{org_id}/token/refresh"]["patch"]["requestBody"]["content"]["application/json"];
 /** JSON representation of our "signer session" file format */
@@ -10,9 +11,9 @@ export interface SignerSessionObject {
     /** The organization ID */
     org_id: string;
     /** The role ID */
-    role_id: string;
+    role_id?: string;
     /** The purpose of the session token */
-    purpose: string;
+    purpose?: string;
     /** The token to include in Authorization header */
     token: string;
     /** Session info */
@@ -29,12 +30,13 @@ export interface SignerSessionLifetime {
     auth: number;
     /** Refresh token lifetime (in seconds). Defaults to one day (86400). */
     refresh?: number;
+    /** Grace lifetime (in seconds). Defaults to 30 seconds (30). */
+    grace?: number;
 }
 /** Manager for signer sessions. */
 export declare class SignerSessionManager extends OrgSessionManager<SignerSessionData> {
     #private;
     readonly cs?: CubeSigner;
-    readonly roleId: string;
     /**
      * @return {string} The current auth token.
      * @internal
@@ -60,7 +62,7 @@ export declare class SignerSessionManager extends OrgSessionManager<SignerSessio
     /**
      * Create a new signer session.
      * @param {CubeSigner} cs The CubeSigner instance
-     * @param {SessionStorage<SignerSessionObject>} storage The session storage to use
+     * @param {SignerSessionStorage} storage The session storage to use
      * @param {string} orgId Org ID
      * @param {string} roleId Role ID
      * @param {string} purpose The purpose of the session
@@ -68,20 +70,30 @@ export declare class SignerSessionManager extends OrgSessionManager<SignerSessio
      * @return {Promise<SignerSessionManager>} New signer session
      */
     static create(cs: CubeSigner, storage: SignerSessionStorage, orgId: string, roleId: string, purpose: string, ttl?: SignerSessionLifetime): Promise<SignerSessionManager>;
+    /**
+     * @param {EnvInterface} env The CubeSigner environment
+     * @param {string} orgId The organization ID
+     * @param {NewSessionResponse} session The session information.
+     * @param {SignerSessionStorage} storage The storage to use for saving the session.
+     * @return {Promise<SignerSessionManager>} New signer session manager.
+     */
+    static createFromSessionInfo(env: EnvInterface, orgId: string, session: NewSessionResponse, storage?: SignerSessionStorage): Promise<SignerSessionManager>;
     /**
      * Uses an existing session to create a new signer session manager.
-     * @param {CubeSigner} cs The CubeSigner instance
-     * @param {SessionStorage<SignerSessionObject>} storage The session storage to use
+     * @param {SignerSessionStorage} storage The session storage to use
+     * @param {CubeSigner} cs Optional CubeSigner instance.
+     *    Currently used for token revocation; will be completely removed
+     *    since token revocation should not require management session.
      * @return {Promise<SingerSession>} New signer session manager
      */
-    static loadFromStorage(cs: CubeSigner, storage: SignerSessionStorage): Promise<SignerSessionManager>;
+    static loadFromStorage(storage: SignerSessionStorage, cs?: CubeSigner): Promise<SignerSessionManager>;
     /**
      * Constructor.
-     * @param {CubeSigner} cs CubeSigner
-     * @param {string} orgId The id of the org associated with this session
-     * @param {string} roleId The id of the role that this session assumes
-     * @param {string} token The authorization token to use
+     * @param {SignerSessionData} sessionData Session data
      * @param {SignerSessionStorage} storage The session storage to use
+     * @param {CubeSigner} cs Optional CubeSigner instance.
+     *    Currently used for token revocation; will be completely removed
+     *    since token revocation should not require management session.
      * @internal
      */
     private constructor();

package/dist/src/session/signer_session_manager.js

@@ -15,10 +15,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignerSessionManager = void 0;
 const util_1 = require("../util");
 const session_manager_1 = require("./session_manager");
+const session_storage_1 = require("./session_storage");
 const defaultSignerSessionLifetime = {
     session: 604800,
     auth: 300,
     refresh: 86400,
+    grace: 30,
 };
 /** Manager for signer sessions. */
 class SignerSessionManager extends session_manager_1.OrgSessionManager {
@@ -44,11 +46,10 @@ class SignerSessionManager extends session_manager_1.OrgSessionManager {
             throw new Error("No management session available");
         }
         const session = await this.storage.retrieve();
-        const resp = await (await this.cs.management()).del("/v0/org/{org_id}/roles/{role_id}/tokens/{session_id}", {
+        const resp = await (await this.cs.management()).del("/v0/org/{org_id}/session/{session_id}", {
             params: {
                 path: {
                     org_id: session.org_id,
-                    role_id: session.role_id,
                     session_id: session.session_info.session_id,
                 },
             },
@@ -63,7 +64,7 @@ class SignerSessionManager extends session_manager_1.OrgSessionManager {
      */
     async isStale() {
         const session = await this.storage.retrieve();
-        return this.hasExpired(session.session_info.auth_token_exp);
+        return this.hasExpired(session.session_info.auth_token_exp * 1000);
     }
     /**
      * Refreshes the session and **UPDATES/MUTATES** self.
@@ -91,7 +92,7 @@ class SignerSessionManager extends session_manager_1.OrgSessionManager {
     /**
      * Create a new signer session.
      * @param {CubeSigner} cs The CubeSigner instance
-     * @param {SessionStorage<SignerSessionObject>} storage The session storage to use
+     * @param {SignerSessionStorage} storage The session storage to use
      * @param {string} orgId Org ID
      * @param {string} roleId Role ID
      * @param {string} purpose The purpose of the session
@@ -106,6 +107,7 @@ class SignerSessionManager extends session_manager_1.OrgSessionManager {
                 auth_lifetime: ttl?.auth || defaultSignerSessionLifetime.auth,
                 refresh_lifetime: ttl?.refresh || defaultSignerSessionLifetime.refresh,
                 session_lifetime: ttl?.session || defaultSignerSessionLifetime.session,
+                grace_lifetime: ttl?.grace || defaultSignerSessionLifetime.grace,
             },
             parseAs: "json",
         });
@@ -114,7 +116,7 @@ class SignerSessionManager extends session_manager_1.OrgSessionManager {
         if (!session_info) {
             throw new Error("Signer session info missing");
         }
-        await storage.save({
+        const sessionData = {
             org_id: orgId,
             role_id: roleId,
             purpose,
@@ -124,36 +126,59 @@ class SignerSessionManager extends session_manager_1.OrgSessionManager {
             env: {
                 ["Dev-CubeSignerStack"]: cs.env,
             },
-        });
-        return new SignerSessionManager(cs, orgId, roleId, data.token, storage);
+        };
+        await storage.save(sessionData);
+        return new SignerSessionManager(sessionData, storage, cs);
+    }
+    /**
+     * @param {EnvInterface} env The CubeSigner environment
+     * @param {string} orgId The organization ID
+     * @param {NewSessionResponse} session The session information.
+     * @param {SignerSessionStorage} storage The storage to use for saving the session.
+     * @return {Promise<SignerSessionManager>} New signer session manager.
+     */
+    static async createFromSessionInfo(env, orgId, session, storage) {
+        const sessionData = {
+            env: {
+                ["Dev-CubeSignerStack"]: env,
+            },
+            org_id: orgId,
+            token: session.token,
+            purpose: "sign via oidc",
+            session_info: session.session_info,
+        };
+        storage ??= new session_storage_1.MemorySessionStorage();
+        await storage.save(sessionData);
+        return await SignerSessionManager.loadFromStorage(storage);
     }
     /**
      * Uses an existing session to create a new signer session manager.
-     * @param {CubeSigner} cs The CubeSigner instance
-     * @param {SessionStorage<SignerSessionObject>} storage The session storage to use
+     * @param {SignerSessionStorage} storage The session storage to use
+     * @param {CubeSigner} cs Optional CubeSigner instance.
+     *    Currently used for token revocation; will be completely removed
+     *    since token revocation should not require management session.
      * @return {Promise<SingerSession>} New signer session manager
      */
-    static async loadFromStorage(cs, storage) {
+    static async loadFromStorage(storage, cs) {
         const session = await storage.retrieve();
-        return new SignerSessionManager(cs, session.org_id, session.role_id, session.token, storage);
+        return new SignerSessionManager(session, storage, cs);
     }
     /**
      * Constructor.
-     * @param {CubeSigner} cs CubeSigner
-     * @param {string} orgId The id of the org associated with this session
-     * @param {string} roleId The id of the role that this session assumes
-     * @param {string} token The authorization token to use
+     * @param {SignerSessionData} sessionData Session data
      * @param {SignerSessionStorage} storage The session storage to use
+     * @param {CubeSigner} cs Optional CubeSigner instance.
+     *    Currently used for token revocation; will be completely removed
+     *    since token revocation should not require management session.
      * @internal
      */
-    constructor(cs, orgId, roleId, token, storage) {
-        super(cs.env, orgId, storage);
+    constructor(sessionData, storage, cs) {
+        super(sessionData.env["Dev-CubeSignerStack"], sessionData.org_id, storage);
         _SignerSessionManager_client.set(this, void 0);
         this.cs = cs;
-        this.roleId = roleId;
-        __classPrivateFieldSet(this, _SignerSessionManager_client, this.createClient(token), "f");
+        __classPrivateFieldSet(this, _SignerSessionManager_client, this.createClient(sessionData.token), "f");
     }
 }
 exports.SignerSessionManager = SignerSessionManager;
 _SignerSessionManager_client = new WeakMap();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signer_session_manager.js","sourceRoot":"","sources":["../../../src/session/signer_session_manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { CubeSigner } from \"..\";\nimport { assertOk } from \"../util\";\nimport { components, paths, Client } from \"../client\";\nimport { HasEnv, OrgSessionManager } from \"./session_manager\";\nimport { SessionStorage } from \"./session_storage\";\n\nexport type ClientSessionInfo = components[\"schemas\"][\"ClientSessionInfo\"];\n\nexport type CreateSignerSessionRequest =\n  paths[\"/v0/org/{org_id}/roles/{role_id}/tokens\"][\"post\"][\"requestBody\"][\"content\"][\"application/json\"];\nexport type RefreshSignerSessionRequest =\n  paths[\"/v1/org/{org_id}/token/refresh\"][\"patch\"][\"requestBody\"][\"content\"][\"application/json\"];\n\n/** JSON representation of our \"signer session\" file format */\nexport interface SignerSessionObject {\n  /** The organization ID */\n  org_id: string;\n  /** The role ID */\n  role_id: string;\n  /** The purpose of the session token */\n  purpose: string;\n  /** The token to include in Authorization header */\n  token: string;\n  /** Session info */\n  session_info: ClientSessionInfo;\n}\n\nexport interface SignerSessionData extends SignerSessionObject, HasEnv {}\n\n/** Type of storage required for signer sessions */\nexport type SignerSessionStorage = SessionStorage<SignerSessionData>;\n\nexport interface SignerSessionLifetime {\n  /** Session lifetime (in seconds). Defaults to one week (604800). */\n  session?: number;\n  /** Auth token lifetime (in seconds). Defaults to five minutes (300). */\n  auth: number;\n  /** Refresh token lifetime (in seconds). Defaults to one day (86400). */\n  refresh?: number;\n}\n\nconst defaultSignerSessionLifetime: SignerSessionLifetime = {\n  session: 604800,\n  auth: 300,\n  refresh: 86400,\n};\n\n/** Manager for signer sessions. */\nexport class SignerSessionManager extends OrgSessionManager<SignerSessionData> {\n  readonly cs?: CubeSigner;\n  readonly roleId: string;\n  #client: Client;\n\n  /**\n   * @return {string} The current auth token.\n   * @internal\n   */\n  async token(): Promise<string> {\n    const session = await this.storage.retrieve();\n    return session.token;\n  }\n\n  /**\n   * Returns a client with the current session and refreshes the current\n   * session. May **UPDATE/MUTATE** self.\n   */\n  async client(): Promise<Client> {\n    await this.refreshIfNeeded();\n    return this.#client;\n  }\n\n  /** Revokes the session. */\n  async revoke(): Promise<void> {\n    if (!this.cs) {\n      throw new Error(\"No management session available\");\n    }\n    const session = await this.storage.retrieve();\n    const resp = await (\n      await this.cs.management()\n    ).del(\"/v0/org/{org_id}/roles/{role_id}/tokens/{session_id}\", {\n      params: {\n        path: {\n          org_id: session.org_id,\n          role_id: session.role_id,\n          session_id: session.session_info.session_id,\n        },\n      },\n      parseAs: \"json\",\n    });\n    assertOk(resp);\n  }\n\n  /**\n   * Returns whether it's time to refresh this token.\n   * @return {boolean} Whether it's time to refresh this token.\n   * @internal\n   */\n  async isStale(): Promise<boolean> {\n    const session = await this.storage.retrieve();\n    return this.hasExpired(session.session_info.auth_token_exp);\n  }\n\n  /**\n   * Refreshes the session and **UPDATES/MUTATES** self.\n   */\n  async refresh(): Promise<void> {\n    const session = await this.storage.retrieve();\n    const csi = session.session_info;\n    const resp = await this.#client.patch(\"/v1/org/{org_id}/token/refresh\", {\n      params: { path: { org_id: session.org_id } },\n      body: <RefreshSignerSessionRequest>{\n        epoch_num: csi.epoch,\n        epoch_token: csi.epoch_token,\n        other_token: csi.refresh_token,\n      },\n      parseAs: \"json\",\n    });\n    const data = assertOk(resp);\n    await this.storage.save(<SignerSessionData>{\n      ...session,\n      session_info: data.session_info,\n      token: data.token,\n    });\n    this.#client = this.createClient(data.token);\n  }\n\n  /**\n   * Create a new signer session.\n   * @param {CubeSigner} cs The CubeSigner instance\n   * @param {SessionStorage<SignerSessionObject>} storage The session storage to use\n   * @param {string} orgId Org ID\n   * @param {string} roleId Role ID\n   * @param {string} purpose The purpose of the session\n   * @param {SignerSessionLifetime} ttl Lifetime settings\n   * @return {Promise<SignerSessionManager>} New signer session\n   */\n  static async create(\n    cs: CubeSigner,\n    storage: SignerSessionStorage,\n    orgId: string,\n    roleId: string,\n    purpose: string,\n    ttl?: SignerSessionLifetime,\n  ): Promise<SignerSessionManager> {\n    const resp = await (\n      await cs.management()\n    ).post(\"/v0/org/{org_id}/roles/{role_id}/tokens\", {\n      params: { path: { org_id: orgId, role_id: roleId } },\n      body: {\n        purpose,\n        auth_lifetime: ttl?.auth || defaultSignerSessionLifetime.auth,\n        refresh_lifetime: ttl?.refresh || defaultSignerSessionLifetime.refresh,\n        session_lifetime: ttl?.session || defaultSignerSessionLifetime.session,\n      },\n      parseAs: \"json\",\n    });\n    const data = assertOk(resp);\n    const session_info = data.session_info;\n    if (!session_info) {\n      throw new Error(\"Signer session info missing\");\n    }\n    await storage.save({\n      org_id: orgId,\n      role_id: roleId,\n      purpose,\n      token: data.token,\n      session_info,\n      // Keep compatibility with tokens produced by CLI\n      env: {\n        [\"Dev-CubeSignerStack\"]: cs.env,\n      },\n    });\n    return new SignerSessionManager(cs, orgId, roleId, data.token, storage);\n  }\n\n  /**\n   * Uses an existing session to create a new signer session manager.\n   * @param {CubeSigner} cs The CubeSigner instance\n   * @param {SessionStorage<SignerSessionObject>} storage The session storage to use\n   * @return {Promise<SingerSession>} New signer session manager\n   */\n  static async loadFromStorage(\n    cs: CubeSigner,\n    storage: SignerSessionStorage,\n  ): Promise<SignerSessionManager> {\n    const session = await storage.retrieve();\n    return new SignerSessionManager(cs, session.org_id, session.role_id, session.token, storage);\n  }\n\n  /**\n   * Constructor.\n   * @param {CubeSigner} cs CubeSigner\n   * @param {string} orgId The id of the org associated with this session\n   * @param {string} roleId The id of the role that this session assumes\n   * @param {string} token The authorization token to use\n   * @param {SignerSessionStorage} storage The session storage to use\n   * @internal\n   */\n  private constructor(\n    cs: CubeSigner,\n    orgId: string,\n    roleId: string,\n    token: string,\n    storage: SignerSessionStorage,\n  ) {\n    super(cs.env, orgId, storage);\n    this.cs = cs;\n    this.roleId = roleId;\n    this.#client = this.createClient(token);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"signer_session_manager.js","sourceRoot":"","sources":["../../../src/session/signer_session_manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { CubeSigner, EnvInterface } from \"..\";\nimport { assertOk } from \"../util\";\nimport { components, paths, Client } from \"../client\";\nimport { HasEnv, OrgSessionManager } from \"./session_manager\";\nimport { MemorySessionStorage, SessionStorage } from \"./session_storage\";\n\nexport type ClientSessionInfo = components[\"schemas\"][\"ClientSessionInfo\"];\nexport type NewSessionResponse = components[\"schemas\"][\"NewSessionResponse\"];\n\nexport type CreateSignerSessionRequest =\n  paths[\"/v0/org/{org_id}/roles/{role_id}/tokens\"][\"post\"][\"requestBody\"][\"content\"][\"application/json\"];\nexport type RefreshSignerSessionRequest =\n  paths[\"/v1/org/{org_id}/token/refresh\"][\"patch\"][\"requestBody\"][\"content\"][\"application/json\"];\n\n/** JSON representation of our \"signer session\" file format */\nexport interface SignerSessionObject {\n  /** The organization ID */\n  org_id: string;\n  /** The role ID */\n  role_id?: string;\n  /** The purpose of the session token */\n  purpose?: string;\n  /** The token to include in Authorization header */\n  token: string;\n  /** Session info */\n  session_info: ClientSessionInfo;\n}\n\nexport interface SignerSessionData extends SignerSessionObject, HasEnv {}\n\n/** Type of storage required for signer sessions */\nexport type SignerSessionStorage = SessionStorage<SignerSessionData>;\n\nexport interface SignerSessionLifetime {\n  /** Session lifetime (in seconds). Defaults to one week (604800). */\n  session?: number;\n  /** Auth token lifetime (in seconds). Defaults to five minutes (300). */\n  auth: number;\n  /** Refresh token lifetime (in seconds). Defaults to one day (86400). */\n  refresh?: number;\n  /** Grace lifetime (in seconds). Defaults to 30 seconds (30). */\n  grace?: number;\n}\n\nconst defaultSignerSessionLifetime: SignerSessionLifetime = {\n  session: 604800,\n  auth: 300,\n  refresh: 86400,\n  grace: 30,\n};\n\n/** Manager for signer sessions. */\nexport class SignerSessionManager extends OrgSessionManager<SignerSessionData> {\n  readonly cs?: CubeSigner;\n  #client: Client;\n\n  /**\n   * @return {string} The current auth token.\n   * @internal\n   */\n  async token(): Promise<string> {\n    const session = await this.storage.retrieve();\n    return session.token;\n  }\n\n  /**\n   * Returns a client with the current session and refreshes the current\n   * session. May **UPDATE/MUTATE** self.\n   */\n  async client(): Promise<Client> {\n    await this.refreshIfNeeded();\n    return this.#client;\n  }\n\n  /** Revokes the session. */\n  async revoke(): Promise<void> {\n    if (!this.cs) {\n      throw new Error(\"No management session available\");\n    }\n    const session = await this.storage.retrieve();\n    const resp = await (\n      await this.cs.management()\n    ).del(\"/v0/org/{org_id}/session/{session_id}\", {\n      params: {\n        path: {\n          org_id: session.org_id,\n          session_id: session.session_info.session_id,\n        },\n      },\n      parseAs: \"json\",\n    });\n    assertOk(resp);\n  }\n\n  /**\n   * Returns whether it's time to refresh this token.\n   * @return {boolean} Whether it's time to refresh this token.\n   * @internal\n   */\n  async isStale(): Promise<boolean> {\n    const session = await this.storage.retrieve();\n    return this.hasExpired(session.session_info.auth_token_exp * 1000);\n  }\n\n  /**\n   * Refreshes the session and **UPDATES/MUTATES** self.\n   */\n  async refresh(): Promise<void> {\n    const session = await this.storage.retrieve();\n    const csi = session.session_info;\n    const resp = await this.#client.patch(\"/v1/org/{org_id}/token/refresh\", {\n      params: { path: { org_id: session.org_id } },\n      body: <RefreshSignerSessionRequest>{\n        epoch_num: csi.epoch,\n        epoch_token: csi.epoch_token,\n        other_token: csi.refresh_token,\n      },\n      parseAs: \"json\",\n    });\n    const data = assertOk(resp);\n    await this.storage.save(<SignerSessionData>{\n      ...session,\n      session_info: data.session_info,\n      token: data.token,\n    });\n    this.#client = this.createClient(data.token);\n  }\n\n  /**\n   * Create a new signer session.\n   * @param {CubeSigner} cs The CubeSigner instance\n   * @param {SignerSessionStorage} storage The session storage to use\n   * @param {string} orgId Org ID\n   * @param {string} roleId Role ID\n   * @param {string} purpose The purpose of the session\n   * @param {SignerSessionLifetime} ttl Lifetime settings\n   * @return {Promise<SignerSessionManager>} New signer session\n   */\n  static async create(\n    cs: CubeSigner,\n    storage: SignerSessionStorage,\n    orgId: string,\n    roleId: string,\n    purpose: string,\n    ttl?: SignerSessionLifetime,\n  ): Promise<SignerSessionManager> {\n    const resp = await (\n      await cs.management()\n    ).post(\"/v0/org/{org_id}/roles/{role_id}/tokens\", {\n      params: { path: { org_id: orgId, role_id: roleId } },\n      body: {\n        purpose,\n        auth_lifetime: ttl?.auth || defaultSignerSessionLifetime.auth,\n        refresh_lifetime: ttl?.refresh || defaultSignerSessionLifetime.refresh,\n        session_lifetime: ttl?.session || defaultSignerSessionLifetime.session,\n        grace_lifetime: ttl?.grace || defaultSignerSessionLifetime.grace,\n      },\n      parseAs: \"json\",\n    });\n    const data = assertOk(resp);\n    const session_info = data.session_info;\n    if (!session_info) {\n      throw new Error(\"Signer session info missing\");\n    }\n    const sessionData = {\n      org_id: orgId,\n      role_id: roleId,\n      purpose,\n      token: data.token,\n      session_info,\n      // Keep compatibility with tokens produced by CLI\n      env: {\n        [\"Dev-CubeSignerStack\"]: cs.env,\n      },\n    };\n    await storage.save(sessionData);\n    return new SignerSessionManager(sessionData, storage, cs);\n  }\n\n  /**\n   * @param {EnvInterface} env The CubeSigner environment\n   * @param {string} orgId The organization ID\n   * @param {NewSessionResponse} session The session information.\n   * @param {SignerSessionStorage} storage The storage to use for saving the session.\n   * @return {Promise<SignerSessionManager>} New signer session manager.\n   */\n  static async createFromSessionInfo(\n    env: EnvInterface,\n    orgId: string,\n    session: NewSessionResponse,\n    storage?: SignerSessionStorage,\n  ): Promise<SignerSessionManager> {\n    const sessionData = {\n      env: {\n        [\"Dev-CubeSignerStack\"]: env,\n      },\n      org_id: orgId,\n      token: session.token,\n      purpose: \"sign via oidc\",\n      session_info: session.session_info,\n    };\n    storage ??= new MemorySessionStorage();\n    await storage.save(sessionData);\n    return await SignerSessionManager.loadFromStorage(storage);\n  }\n\n  /**\n   * Uses an existing session to create a new signer session manager.\n   * @param {SignerSessionStorage} storage The session storage to use\n   * @param {CubeSigner} cs Optional CubeSigner instance.\n   *    Currently used for token revocation; will be completely removed\n   *    since token revocation should not require management session.\n   * @return {Promise<SingerSession>} New signer session manager\n   */\n  static async loadFromStorage(\n    storage: SignerSessionStorage,\n    cs?: CubeSigner,\n  ): Promise<SignerSessionManager> {\n    const session = await storage.retrieve();\n    return new SignerSessionManager(session, storage, cs);\n  }\n\n  /**\n   * Constructor.\n   * @param {SignerSessionData} sessionData Session data\n   * @param {SignerSessionStorage} storage The session storage to use\n   * @param {CubeSigner} cs Optional CubeSigner instance.\n   *    Currently used for token revocation; will be completely removed\n   *    since token revocation should not require management session.\n   * @internal\n   */\n  private constructor(\n    sessionData: SignerSessionData,\n    storage: SignerSessionStorage,\n    cs?: CubeSigner,\n  ) {\n    super(sessionData.env[\"Dev-CubeSignerStack\"], sessionData.org_id, storage);\n    this.cs = cs;\n    this.#client = this.createClient(sessionData.token);\n  }\n}\n"]}