matrix-react-sdk
Version:
SDK for matrix.org using React
377 lines (325 loc) • 38.6 kB
JavaScript
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _url = _interopRequireDefault(require("url"));
var _SettingsStore = _interopRequireDefault(require("./settings/SettingsStore"));
var _Terms = require("./Terms");
var _MatrixClientPeg = require("./MatrixClientPeg");
var _browserRequest = _interopRequireDefault(require("browser-request"));
var _SdkConfig = _interopRequireDefault(require("./SdkConfig"));
var _serviceTypes = require("matrix-js-sdk/src/service-types");
/*
Copyright 2016, 2019, 2021 The Matrix.org Foundation C.I.C.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// The version of the integration manager API we're intending to work with
const imApiVersion = "1.1"; // TODO: Generify the name of this class and all components within - it's not just for Scalar.
class ScalarAuthClient {
constructor(apiUrl
/*: string*/
, uiUrl
/*: string*/
) {
this.apiUrl
/*:: */
= apiUrl
/*:: */
;
this.uiUrl
/*:: */
= uiUrl
/*:: */
;
(0, _defineProperty2.default)(this, "scalarToken", void 0);
(0, _defineProperty2.default)(this, "termsInteractionCallback", void 0);
(0, _defineProperty2.default)(this, "isDefaultManager", void 0);
this.scalarToken = null; // `undefined` to allow `startTermsFlow` to fallback to a default
// callback if this is unset.
this.termsInteractionCallback = undefined; // We try and store the token on a per-manager basis, but need a fallback
// for the default manager.
const configApiUrl = _SdkConfig.default.get()['integrations_rest_url'];
const configUiUrl = _SdkConfig.default.get()['integrations_ui_url'];
this.isDefaultManager = apiUrl === configApiUrl && configUiUrl === uiUrl;
}
writeTokenToStore() {
window.localStorage.setItem("mx_scalar_token_at_" + this.apiUrl, this.scalarToken);
if (this.isDefaultManager) {
// We remove the old token from storage to migrate upwards. This is safe
// to do because even if the user switches to /app when this is on /develop
// they'll at worst register for a new token.
window.localStorage.removeItem("mx_scalar_token"); // no-op when not present
}
}
readTokenFromStore()
/*: string*/
{
let token = window.localStorage.getItem("mx_scalar_token_at_" + this.apiUrl);
if (!token && this.isDefaultManager) {
token = window.localStorage.getItem("mx_scalar_token");
}
return token;
}
readToken()
/*: string*/
{
if (this.scalarToken) return this.scalarToken;
return this.readTokenFromStore();
}
setTermsInteractionCallback(callback) {
this.termsInteractionCallback = callback;
}
connect()
/*: Promise<void>*/
{
return this.getScalarToken().then(tok => {
this.scalarToken = tok;
});
}
hasCredentials()
/*: boolean*/
{
return this.scalarToken != null; // undef or null
} // Returns a promise that resolves to a scalar_token string
getScalarToken()
/*: Promise<string>*/
{
const token = this.readToken();
if (!token) {
return this.registerForToken();
} else {
return this.checkToken(token).catch(e => {
if (e instanceof _Terms.TermsNotSignedError) {
// retrying won't help this
throw e;
}
return this.registerForToken();
});
}
}
getAccountName(token
/*: string*/
)
/*: Promise<string>*/
{
const url = this.apiUrl + "/account";
return new Promise(function (resolve, reject) {
(0, _browserRequest.default)({
method: "GET",
uri: url,
qs: {
scalar_token: token,
v: imApiVersion
},
json: true
}, (err, response, body) => {
if (err) {
reject(err);
} else if (body && body.errcode === 'M_TERMS_NOT_SIGNED') {
reject(new _Terms.TermsNotSignedError());
} else if (response.statusCode / 100 !== 2) {
reject(body);
} else if (!body || !body.user_id) {
reject(new Error("Missing user_id in response"));
} else {
resolve(body.user_id);
}
});
});
}
checkToken(token
/*: string*/
)
/*: Promise<string>*/
{
return this.getAccountName(token).then(userId => {
const me = _MatrixClientPeg.MatrixClientPeg.get().getUserId();
if (userId !== me) {
throw new Error("Scalar token is owned by someone else: " + me);
}
return token;
}).catch(e => {
if (e instanceof _Terms.TermsNotSignedError) {
console.log("Integration manager requires new terms to be agreed to"); // The terms endpoints are new and so live on standard _matrix prefixes,
// but IM rest urls are currently configured with paths, so remove the
// path from the base URL before passing it to the js-sdk
// We continue to use the full URL for the calls done by
// matrix-react-sdk, but the standard terms API called
// by the js-sdk lives on the standard _matrix path. This means we
// don't support running IMs on a non-root path, but it's the only
// realistic way of transitioning to _matrix paths since configs in
// the wild contain bits of the API path.
// Once we've fully transitioned to _matrix URLs, we can give people
// a grace period to update their configs, then use the rest url as
// a regular base url.
const parsedImRestUrl = _url.default.parse(this.apiUrl);
parsedImRestUrl.path = '';
parsedImRestUrl.pathname = '';
return (0, _Terms.startTermsFlow)([new _Terms.Service(_serviceTypes.SERVICE_TYPES.IM, _url.default.format(parsedImRestUrl), token)], this.termsInteractionCallback).then(() => {
return token;
});
} else {
throw e;
}
});
}
registerForToken()
/*: Promise<string>*/
{
// Get openid bearer token from the HS as the first part of our dance
return _MatrixClientPeg.MatrixClientPeg.get().getOpenIdToken().then(tokenObject => {
// Now we can send that to scalar and exchange it for a scalar token
return this.exchangeForScalarToken(tokenObject);
}).then(token => {
// Validate it (this mostly checks to see if the IM needs us to agree to some terms)
return this.checkToken(token);
}).then(token => {
this.scalarToken = token;
this.writeTokenToStore();
return token;
});
}
exchangeForScalarToken(openidTokenObject
/*: any*/
)
/*: Promise<string>*/
{
const scalarRestUrl = this.apiUrl;
return new Promise(function (resolve, reject) {
(0, _browserRequest.default)({
method: 'POST',
uri: scalarRestUrl + '/register',
qs: {
v: imApiVersion
},
body: openidTokenObject,
json: true
}, (err, response, body) => {
if (err) {
reject(err);
} else if (response.statusCode / 100 !== 2) {
reject(new Error(`Scalar request failed: ${response.statusCode}`));
} else if (!body || !body.scalar_token) {
reject(new Error("Missing scalar_token in response"));
} else {
resolve(body.scalar_token);
}
});
});
}
getScalarPageTitle(url
/*: string*/
)
/*: Promise<string>*/
{
let scalarPageLookupUrl = this.apiUrl + '/widgets/title_lookup';
scalarPageLookupUrl = this.getStarterLink(scalarPageLookupUrl);
scalarPageLookupUrl += '&curl=' + encodeURIComponent(url);
return new Promise(function (resolve, reject) {
(0, _browserRequest.default)({
method: 'GET',
uri: scalarPageLookupUrl,
json: true
}, (err, response, body) => {
if (err) {
reject(err);
} else if (response.statusCode / 100 !== 2) {
reject(new Error(`Scalar request failed: ${response.statusCode}`));
} else if (!body) {
reject(new Error("Missing page title in response"));
} else {
let title = "";
if (body.page_title_cache_item && body.page_title_cache_item.cached_title) {
title = body.page_title_cache_item.cached_title;
}
resolve(title);
}
});
});
}
/**
* Mark all assets associated with the specified widget as "disabled" in the
* integration manager database.
* This can be useful to temporarily prevent purchased assets from being displayed.
* @param {WidgetType} widgetType The Widget Type to disable assets for
* @param {string} widgetId The widget ID to disable assets for
* @return {Promise} Resolves on completion
*/
disableWidgetAssets(widgetType
/*: WidgetType*/
, widgetId
/*: string*/
)
/*: Promise<void>*/
{
let url = this.apiUrl + '/widgets/set_assets_state';
url = this.getStarterLink(url);
return new Promise((resolve, reject) => {
(0, _browserRequest.default)({
method: 'GET',
// XXX: Actions shouldn't be GET requests
uri: url,
json: true,
qs: {
'widget_type': widgetType.preferred,
'widget_id': widgetId,
'state': 'disable'
}
}, (err, response, body) => {
if (err) {
reject(err);
} else if (response.statusCode / 100 !== 2) {
reject(new Error(`Scalar request failed: ${response.statusCode}`));
} else if (!body) {
reject(new Error("Failed to set widget assets state"));
} else {
resolve();
}
});
});
}
getScalarInterfaceUrlForRoom(room
/*: Room*/
, screen
/*: string*/
, id
/*: string*/
)
/*: string*/
{
const roomId = room.roomId;
const roomName = room.name;
let url = this.uiUrl;
url += "?scalar_token=" + encodeURIComponent(this.scalarToken);
url += "&room_id=" + encodeURIComponent(roomId);
url += "&room_name=" + encodeURIComponent(roomName);
url += "&theme=" + encodeURIComponent(_SettingsStore.default.getValue("theme"));
if (id) {
url += '&integ_id=' + encodeURIComponent(id);
}
if (screen) {
url += '&screen=' + encodeURIComponent(screen);
}
return url;
}
getStarterLink(starterLinkUrl
/*: string*/
)
/*: string*/
{
return starterLinkUrl + "?scalar_token=" + encodeURIComponent(this.scalarToken);
}
}
exports.default = ScalarAuthClient;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/ScalarAuthClient.ts"],"names":["imApiVersion","ScalarAuthClient","constructor","apiUrl","uiUrl","scalarToken","termsInteractionCallback","undefined","configApiUrl","SdkConfig","get","configUiUrl","isDefaultManager","writeTokenToStore","window","localStorage","setItem","removeItem","readTokenFromStore","token","getItem","readToken","setTermsInteractionCallback","callback","connect","getScalarToken","then","tok","hasCredentials","registerForToken","checkToken","catch","e","TermsNotSignedError","getAccountName","url","Promise","resolve","reject","method","uri","qs","scalar_token","v","json","err","response","body","errcode","statusCode","user_id","Error","userId","me","MatrixClientPeg","getUserId","console","log","parsedImRestUrl","parse","path","pathname","Service","SERVICE_TYPES","IM","format","getOpenIdToken","tokenObject","exchangeForScalarToken","openidTokenObject","scalarRestUrl","getScalarPageTitle","scalarPageLookupUrl","getStarterLink","encodeURIComponent","title","page_title_cache_item","cached_title","disableWidgetAssets","widgetType","widgetId","preferred","getScalarInterfaceUrlForRoom","room","screen","id","roomId","roomName","name","SettingsStore","getValue","starterLinkUrl"],"mappings":"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","sourcesContent":["/*\nCopyright 2016, 2019, 2021 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport url from 'url';\nimport SettingsStore from \"./settings/SettingsStore\";\nimport { Service, startTermsFlow, TermsInteractionCallback, TermsNotSignedError } from './Terms';\nimport {MatrixClientPeg} from \"./MatrixClientPeg\";\nimport request from \"browser-request\";\n\nimport SdkConfig from \"./SdkConfig\";\nimport {WidgetType} from \"./widgets/WidgetType\";\nimport {SERVICE_TYPES} from \"matrix-js-sdk/src/service-types\";\nimport { Room } from \"matrix-js-sdk/src/models/room\";\n\n// The version of the integration manager API we're intending to work with\nconst imApiVersion = \"1.1\";\n\n// TODO: Generify the name of this class and all components within - it's not just for Scalar.\n\nexport default class ScalarAuthClient {\n    private scalarToken: string;\n    private termsInteractionCallback: TermsInteractionCallback;\n    private isDefaultManager: boolean;\n\n    constructor(private apiUrl: string, private uiUrl: string) {\n        this.scalarToken = null;\n        // `undefined` to allow `startTermsFlow` to fallback to a default\n        // callback if this is unset.\n        this.termsInteractionCallback = undefined;\n\n        // We try and store the token on a per-manager basis, but need a fallback\n        // for the default manager.\n        const configApiUrl = SdkConfig.get()['integrations_rest_url'];\n        const configUiUrl = SdkConfig.get()['integrations_ui_url'];\n        this.isDefaultManager = apiUrl === configApiUrl && configUiUrl === uiUrl;\n    }\n\n    private writeTokenToStore() {\n        window.localStorage.setItem(\"mx_scalar_token_at_\" + this.apiUrl, this.scalarToken);\n        if (this.isDefaultManager) {\n            // We remove the old token from storage to migrate upwards. This is safe\n            // to do because even if the user switches to /app when this is on /develop\n            // they'll at worst register for a new token.\n            window.localStorage.removeItem(\"mx_scalar_token\"); // no-op when not present\n        }\n    }\n\n    private readTokenFromStore(): string {\n        let token = window.localStorage.getItem(\"mx_scalar_token_at_\" + this.apiUrl);\n        if (!token && this.isDefaultManager) {\n            token = window.localStorage.getItem(\"mx_scalar_token\");\n        }\n        return token;\n    }\n\n    private readToken(): string {\n        if (this.scalarToken) return this.scalarToken;\n        return this.readTokenFromStore();\n    }\n\n    setTermsInteractionCallback(callback) {\n        this.termsInteractionCallback = callback;\n    }\n\n    connect(): Promise<void> {\n        return this.getScalarToken().then((tok) => {\n            this.scalarToken = tok;\n        });\n    }\n\n    hasCredentials(): boolean {\n        return this.scalarToken != null; // undef or null\n    }\n\n    // Returns a promise that resolves to a scalar_token string\n    getScalarToken(): Promise<string> {\n        const token = this.readToken();\n\n        if (!token) {\n            return this.registerForToken();\n        } else {\n            return this.checkToken(token).catch((e) => {\n                if (e instanceof TermsNotSignedError) {\n                    // retrying won't help this\n                    throw e;\n                }\n                return this.registerForToken();\n            });\n        }\n    }\n\n    private getAccountName(token: string): Promise<string> {\n        const url = this.apiUrl + \"/account\";\n\n        return new Promise(function(resolve, reject) {\n            request({\n                method: \"GET\",\n                uri: url,\n                qs: {scalar_token: token, v: imApiVersion},\n                json: true,\n            }, (err, response, body) => {\n                if (err) {\n                    reject(err);\n                } else if (body && body.errcode === 'M_TERMS_NOT_SIGNED') {\n                    reject(new TermsNotSignedError());\n                } else if (response.statusCode / 100 !== 2) {\n                    reject(body);\n                } else if (!body || !body.user_id) {\n                    reject(new Error(\"Missing user_id in response\"));\n                } else {\n                    resolve(body.user_id);\n                }\n            });\n        });\n    }\n\n    private checkToken(token: string): Promise<string> {\n        return this.getAccountName(token).then(userId => {\n            const me = MatrixClientPeg.get().getUserId();\n            if (userId !== me) {\n                throw new Error(\"Scalar token is owned by someone else: \" + me);\n            }\n            return token;\n        }).catch((e) => {\n            if (e instanceof TermsNotSignedError) {\n                console.log(\"Integration manager requires new terms to be agreed to\");\n                // The terms endpoints are new and so live on standard _matrix prefixes,\n                // but IM rest urls are currently configured with paths, so remove the\n                // path from the base URL before passing it to the js-sdk\n\n                // We continue to use the full URL for the calls done by\n                // matrix-react-sdk, but the standard terms API called\n                // by the js-sdk lives on the standard _matrix path. This means we\n                // don't support running IMs on a non-root path, but it's the only\n                // realistic way of transitioning to _matrix paths since configs in\n                // the wild contain bits of the API path.\n\n                // Once we've fully transitioned to _matrix URLs, we can give people\n                // a grace period to update their configs, then use the rest url as\n                // a regular base url.\n                const parsedImRestUrl = url.parse(this.apiUrl);\n                parsedImRestUrl.path = '';\n                parsedImRestUrl.pathname = '';\n                return startTermsFlow([new Service(\n                    SERVICE_TYPES.IM,\n                    url.format(parsedImRestUrl),\n                    token,\n                )], this.termsInteractionCallback).then(() => {\n                    return token;\n                });\n            } else {\n                throw e;\n            }\n        });\n    }\n\n    registerForToken(): Promise<string> {\n        // Get openid bearer token from the HS as the first part of our dance\n        return MatrixClientPeg.get().getOpenIdToken().then((tokenObject) => {\n            // Now we can send that to scalar and exchange it for a scalar token\n            return this.exchangeForScalarToken(tokenObject);\n        }).then((token) => {\n            // Validate it (this mostly checks to see if the IM needs us to agree to some terms)\n            return this.checkToken(token);\n        }).then((token) => {\n            this.scalarToken = token;\n            this.writeTokenToStore();\n            return token;\n        });\n    }\n\n    exchangeForScalarToken(openidTokenObject: any): Promise<string> {\n        const scalarRestUrl = this.apiUrl;\n\n        return new Promise(function(resolve, reject) {\n            request({\n                method: 'POST',\n                uri: scalarRestUrl + '/register',\n                qs: {v: imApiVersion},\n                body: openidTokenObject,\n                json: true,\n            }, (err, response, body) => {\n                if (err) {\n                    reject(err);\n                } else if (response.statusCode / 100 !== 2) {\n                    reject(new Error(`Scalar request failed: ${response.statusCode}`));\n                } else if (!body || !body.scalar_token) {\n                    reject(new Error(\"Missing scalar_token in response\"));\n                } else {\n                    resolve(body.scalar_token);\n                }\n            });\n        });\n    }\n\n    getScalarPageTitle(url: string): Promise<string> {\n        let scalarPageLookupUrl = this.apiUrl + '/widgets/title_lookup';\n        scalarPageLookupUrl = this.getStarterLink(scalarPageLookupUrl);\n        scalarPageLookupUrl += '&curl=' + encodeURIComponent(url);\n\n        return new Promise(function(resolve, reject) {\n            request({\n                method: 'GET',\n                uri: scalarPageLookupUrl,\n                json: true,\n            }, (err, response, body) => {\n                if (err) {\n                    reject(err);\n                } else if (response.statusCode / 100 !== 2) {\n                    reject(new Error(`Scalar request failed: ${response.statusCode}`));\n                } else if (!body) {\n                    reject(new Error(\"Missing page title in response\"));\n                } else {\n                    let title = \"\";\n                    if (body.page_title_cache_item && body.page_title_cache_item.cached_title) {\n                        title = body.page_title_cache_item.cached_title;\n                    }\n                    resolve(title);\n                }\n            });\n        });\n    }\n\n    /**\n     * Mark all assets associated with the specified widget as \"disabled\" in the\n     * integration manager database.\n     * This can be useful to temporarily prevent purchased assets from being displayed.\n     * @param  {WidgetType} widgetType The Widget Type to disable assets for\n     * @param  {string} widgetId   The widget ID to disable assets for\n     * @return {Promise}           Resolves on completion\n     */\n    disableWidgetAssets(widgetType: WidgetType, widgetId: string): Promise<void> {\n        let url = this.apiUrl + '/widgets/set_assets_state';\n        url = this.getStarterLink(url);\n        return new Promise<void>((resolve, reject) => {\n            request({\n                method: 'GET', // XXX: Actions shouldn't be GET requests\n                uri: url,\n                json: true,\n                qs: {\n                    'widget_type': widgetType.preferred,\n                    'widget_id': widgetId,\n                    'state': 'disable',\n                },\n            }, (err, response, body) => {\n                if (err) {\n                    reject(err);\n                } else if (response.statusCode / 100 !== 2) {\n                    reject(new Error(`Scalar request failed: ${response.statusCode}`));\n                } else if (!body) {\n                    reject(new Error(\"Failed to set widget assets state\"));\n                } else {\n                    resolve();\n                }\n            });\n        });\n    }\n\n    getScalarInterfaceUrlForRoom(room: Room, screen: string, id: string): string {\n        const roomId = room.roomId;\n        const roomName = room.name;\n        let url = this.uiUrl;\n        url += \"?scalar_token=\" + encodeURIComponent(this.scalarToken);\n        url += \"&room_id=\" + encodeURIComponent(roomId);\n        url += \"&room_name=\" + encodeURIComponent(roomName);\n        url += \"&theme=\" + encodeURIComponent(SettingsStore.getValue(\"theme\"));\n        if (id) {\n            url += '&integ_id=' + encodeURIComponent(id);\n        }\n        if (screen) {\n            url += '&screen=' + encodeURIComponent(screen);\n        }\n        return url;\n    }\n\n    getStarterLink(starterLinkUrl: string): string {\n        return starterLinkUrl + \"?scalar_token=\" + encodeURIComponent(this.scalarToken);\n    }\n}\n"]}