656 lines
23 KiB
TypeScript
656 lines
23 KiB
TypeScript
// Metro module 13571 (f13572).
|
|
import _slicedToArray from "../../../../_bundle/_slicedToArray";
|
|
import ApplicationStore from "../../../applications/ApplicationStore";
|
|
import ApplicationRecord from "../../../../records/ApplicationRecord";
|
|
import UserStore from "../../../../stores/UserStore";
|
|
import { RPC_AUTHENTICATED_SCOPE, TransportTypes, RPC_PRIVATE_SCOPE } from "../../Constants";
|
|
import { ApplicationFlags, RPCErrors, Endpoints, RPCCommands } from "../../../../Constants";
|
|
import LeakyBucket from "../../../../_bundle/LeakyBucket";
|
|
import Durations from "../../../../utils/Durations";
|
|
import { Storage } from "../../../../_bundle/Module595";
|
|
import RPCError from "../../RPCError";
|
|
import { hasApplicationFlag } from "../../../applications/utils/ApplicationFlagUtils";
|
|
import { ApplicationIntegrationType } from "../../../../_bundle/Module8028";
|
|
import { fetchApplication } from "../../../premium_apps/ApplicationSubscriptionsHttpApi";
|
|
import * as _actions from "../../../oauth2/actions";
|
|
import { fetchAuthorization } from "../../../oauth2/actions";
|
|
import { getDisclosures } from "../../../applications/disclosures";
|
|
import { OAuth2Prompts } from "../../../oauth2/types";
|
|
import { NONE } from "../../../../utils/PermissionUtils";
|
|
import { deserialize } from "../../../../_bundle/HighLow";
|
|
import { HTTP } from "../../../../_bundle/sendRequest";
|
|
import Dispatcher from "../../../../Dispatcher";
|
|
import { createRPCCommand } from "../../../../_bundle/Module13535";
|
|
import { OAuth2Scopes } from "../../../../_bundle/Module8174";
|
|
import Module1464 from "../../../../_bundle/Module1464";
|
|
function $mk116550($env) {
|
|
return function isUserInstallable(a0) {
|
|
let r12 = hasApplicationFlag(a0, ApplicationFlags.EMBEDDED);
|
|
if (r12) {
|
|
const r2 = a0 == null;
|
|
let r13 = void 0;
|
|
if (!r2) {
|
|
const integrationTypesConfig = a0.integrationTypesConfig;
|
|
r13 = integrationTypesConfig == null ? void 0 : integrationTypesConfig[ApplicationIntegrationType.USER_INSTALL];
|
|
}
|
|
r12 = r13 != null;
|
|
}
|
|
return r12;
|
|
};
|
|
}
|
|
function $mk116551($env) {
|
|
return (a0) => {
|
|
if (a0 == null) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.UNKNOWN_ERROR
|
|
}, "Unknown error occurred");
|
|
}
|
|
const r18 = a0.split(/#|\?/);
|
|
const r26 = Module1464.parse(r18[r18.length - 1]);
|
|
if (r26.error != null) {
|
|
const r58 = {
|
|
errorCode: RPCErrors.OAUTH2_ERROR
|
|
};
|
|
const error = r26.error;
|
|
let error_description = r26.error_description;
|
|
if (error_description == null) {
|
|
error_description = "unknown error";
|
|
}
|
|
throw new RPCError(r58, `OAuth2 Error: ${error}: ${error_description}`);
|
|
}
|
|
const r28 = $env;
|
|
const r10 = r28[2];
|
|
const { access_token, scope, expires_in } = r26;
|
|
let r34 = Storage.get(c9428_16);
|
|
if (r34 == null) {
|
|
r34 = {};
|
|
}
|
|
r34[r10] = {
|
|
accessToken: access_token,
|
|
scope,
|
|
expires: Date.now() + expires_in
|
|
};
|
|
Storage.set(c9428_16, r34);
|
|
return (0, authenticate)(r28[0], r26.access_token);
|
|
};
|
|
}
|
|
let authenticate, c9428_16, c9428_17;
|
|
let env9428 = {};
|
|
const authorizeWithPrompt = async function authorizeWithPrompt(c27516_0, c27516_1, c27516_2) {
|
|
let r300, r502, location2;
|
|
let c27516_3, createFromServer, c27516_5, c27516_6, c27516_7, c27516_8, c27516_10;
|
|
let c27516_9 = 0;
|
|
const r23 = env9428;
|
|
L57: {
|
|
L45: {
|
|
try {
|
|
let env30649;
|
|
c27516_8 = r23;
|
|
const r58 = env30649 = {
|
|
$parent: r23
|
|
};
|
|
c27516_7 = r58;
|
|
env30649[0] = void 0;
|
|
env30649[1] = void 0;
|
|
env30649[2] = void 0;
|
|
env30649[3] = void 0;
|
|
env30649[4] = void 0;
|
|
env30649[5] = void 0;
|
|
env30649[6] = void 0;
|
|
env30649[7] = void 0;
|
|
env30649[8] = void 0;
|
|
env30649[9] = void 0;
|
|
env30649[10] = void 0;
|
|
env30649[11] = void 0;
|
|
env30649[12] = void 0;
|
|
env30649[13] = void 0;
|
|
env30649[14] = void 0;
|
|
env30649[15] = void 0;
|
|
env30649[16] = void 0;
|
|
env30649[17] = void 0;
|
|
env30649[18] = void 0;
|
|
env30649[0] = c27516_0.client_id;
|
|
let response_type = c27516_0.response_type;
|
|
if (response_type === void 0) {
|
|
response_type = "code";
|
|
}
|
|
env30649[1] = response_type;
|
|
env30649[2] = c27516_0.redirect_uri;
|
|
env30649[3] = c27516_0.code_challenge;
|
|
env30649[4] = c27516_0.code_challenge_method;
|
|
env30649[5] = c27516_0.state;
|
|
env30649[6] = c27516_0.nonce;
|
|
env30649[7] = c27516_0.scope;
|
|
env30649[8] = c27516_0.permissions;
|
|
env30649[9] = c27516_0.guild_id;
|
|
env30649[10] = c27516_0.channel_id;
|
|
env30649[11] = c27516_0.prompt;
|
|
env30649[12] = c27516_0.disable_guild_select;
|
|
env30649[13] = c27516_0.integration_type;
|
|
env30649[14] = c27516_0.pid;
|
|
env30649[15] = c27516_0.signal;
|
|
env30649[16] = c27516_0.isSocketRpcPrivateScope;
|
|
env30649[17] = c27516_1;
|
|
env30649[18] = c27516_2;
|
|
env30649[19] = void 0;
|
|
env30649[20] = void 0;
|
|
env30649[21] = void 0;
|
|
env30649[22] = void 0;
|
|
env30649[23] = void 0;
|
|
env30649[24] = void 0;
|
|
env30649[25] = void 0;
|
|
env30649[26] = void 0;
|
|
env30649[27] = void 0;
|
|
env30649[28] = void 0;
|
|
env30649[29] = void 0;
|
|
env30649[30] = void 0;
|
|
env30649[31] = void 0;
|
|
await void 0;
|
|
const r100 = "Redirect URI cannot be used in the RPC OAuth2 Authorization flow";
|
|
if (env30649[15]?.aborted) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.UNKNOWN_ERROR
|
|
}, "Request aborted");
|
|
}
|
|
if (env30649[0] == null) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.OAUTH2_ERROR
|
|
}, "No Client ID provided");
|
|
}
|
|
if (!env30649[16] && env30649[2] != null) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.OAUTH2_ERROR
|
|
}, r100);
|
|
}
|
|
env30649[23] = [];
|
|
if (typeof env30649[7] === "string") {
|
|
env30649[23] = env30649[7].split(" ").filter((item) => item.length > 0);
|
|
} else if (Array.isArray(env30649[7])) {
|
|
env30649[23] = env30649[7];
|
|
}
|
|
if (UserStore.getCurrentUser() == null) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.OAUTH2_ERROR
|
|
}, "Client is not logged in");
|
|
}
|
|
L36: {
|
|
if (env30649[13] != null) {
|
|
env30649[19] = Number(env30649[13]);
|
|
} else {
|
|
env30649[32] = $mk116550(env9428);
|
|
env30649[24] = ApplicationStore.getApplication(env30649[0]);
|
|
if (!(0, env30649[32])(env30649[24])) {
|
|
c27516_6 = env30649[32];
|
|
c27516_5 = ApplicationRecord;
|
|
createFromServer = ApplicationRecord.createFromServer;
|
|
const application = await fetchApplication(env30649[0], env30649[15]);
|
|
const r256 = c27516_5;
|
|
const r257 = c27516_6;
|
|
const r259 = createFromServer.call(r256, application);
|
|
env30649[24] = r259;
|
|
env30649[19] = r257(r259) ? ApplicationIntegrationType.USER_INSTALL : ApplicationIntegrationType.GUILD_INSTALL;
|
|
c27516_9 = 1;
|
|
r300 = Promise.all([fetchAuthorization({
|
|
clientId: env30649[0],
|
|
scopes: env30649[23],
|
|
responseType: env30649[1],
|
|
redirectUri: env30649[2],
|
|
codeChallenge: env30649[3],
|
|
codeChallengeMethod: env30649[4],
|
|
state: env30649[5],
|
|
integrationType: env30649[19],
|
|
signal: env30649[15]
|
|
}), getDisclosures(env30649[0])]);
|
|
break L36;
|
|
}
|
|
env30649[19] = ApplicationIntegrationType.USER_INSTALL;
|
|
}
|
|
c27516_9 = 1;
|
|
r300 = Promise.all([fetchAuthorization({
|
|
clientId: env30649[0],
|
|
scopes: env30649[23],
|
|
responseType: env30649[1],
|
|
redirectUri: env30649[2],
|
|
codeChallenge: env30649[3],
|
|
codeChallengeMethod: env30649[4],
|
|
state: env30649[5],
|
|
integrationType: env30649[19],
|
|
signal: env30649[15]
|
|
}), getDisclosures(env30649[0])]);
|
|
}
|
|
env30649[25] = await r300;
|
|
env30649[26] = (0, _slicedToArray)(env30649[25], 2);
|
|
env30649[20] = env30649[26][0];
|
|
env30649[27] = env30649[26][1];
|
|
env30649[21] = env30649[27].disclosures;
|
|
env30649[22] = env30649[27].allAcked;
|
|
c27516_9 = 0;
|
|
if (env30649[11] === OAuth2Prompts.NONE && env30649[20] != null && env30649[20].authorized) {
|
|
if (env30649[22]) {
|
|
c27516_9 = 2;
|
|
location2 = (await _actions.authorize({
|
|
authorize: true,
|
|
clientId: env30649[0],
|
|
scopes: env30649[23],
|
|
responseType: env30649[1],
|
|
redirectUri: env30649[2],
|
|
codeChallenge: env30649[3],
|
|
codeChallengeMethod: env30649[4],
|
|
state: env30649[5],
|
|
nonce: env30649[6],
|
|
integrationType: env30649[19]
|
|
})).location;
|
|
c27516_9 = 0;
|
|
break L45;
|
|
}
|
|
}
|
|
const r355 = env30649[18];
|
|
if (r355 != null) {
|
|
r355(env30649[20].application, env30649[10], env30649[14]);
|
|
}
|
|
env30649[30] = NONE;
|
|
c27516_9 = 3;
|
|
const r427 = env30649[8];
|
|
c27516_3 = r427;
|
|
if (r427 == null) {
|
|
c27516_3 = 0;
|
|
}
|
|
env30649[30] = deserialize(c27516_3);
|
|
c27516_9 = 0;
|
|
env30649[31] = void 0;
|
|
if (env30649[20].integration_type != null && Object.values(ApplicationIntegrationType).includes(env30649[20].integration_type)) {
|
|
const map = new Map();
|
|
env30649[31] = map;
|
|
map.set(env30649[20].integration_type, env30649[20]);
|
|
}
|
|
if (c9428_17[env30649[20].application.id] != null) {
|
|
await c9428_17[env30649[20].application.id].process();
|
|
if (!env30649[15]?.aborted) {
|
|
r502 = (0, env30649[17])({
|
|
clientId: env30649[0],
|
|
authorizations: env30649[31],
|
|
scopes: env30649[23],
|
|
parsedPermissions: env30649[30],
|
|
responseType: env30649[1],
|
|
redirectUri: env30649[2],
|
|
codeChallenge: env30649[3],
|
|
codeChallengeMethod: env30649[4],
|
|
state: env30649[5],
|
|
guildId: env30649[9],
|
|
channelId: env30649[10],
|
|
prompt: env30649[11],
|
|
disableGuildSelect: env30649[12],
|
|
disclosures: env30649[21],
|
|
integrationType: env30649[19],
|
|
pid: env30649[14],
|
|
signal: env30649[15]
|
|
});
|
|
break L57;
|
|
}
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.UNKNOWN_ERROR
|
|
}, "Request aborted");
|
|
}
|
|
r502 = (0, env30649[17])({
|
|
clientId: env30649[0],
|
|
authorizations: env30649[31],
|
|
scopes: env30649[23],
|
|
parsedPermissions: env30649[30],
|
|
responseType: env30649[1],
|
|
redirectUri: env30649[2],
|
|
codeChallenge: env30649[3],
|
|
codeChallengeMethod: env30649[4],
|
|
state: env30649[5],
|
|
guildId: env30649[9],
|
|
channelId: env30649[10],
|
|
prompt: env30649[11],
|
|
disableGuildSelect: env30649[12],
|
|
disclosures: env30649[21],
|
|
integrationType: env30649[19],
|
|
pid: env30649[14],
|
|
signal: env30649[15]
|
|
});
|
|
break L57;
|
|
} catch ($e) {
|
|
const r56 = $e;
|
|
let r8 = r56;
|
|
c27516_10 = r56;
|
|
let r57 = c27516_9;
|
|
if (r57 !== 0) {
|
|
while (true) {
|
|
if (r57 === 1) {
|
|
try {
|
|
const r774 = c27516_10;
|
|
c27516_9 = 0;
|
|
env30649[28] = r774.body;
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.OAUTH2_ERROR
|
|
}, `OAuth2 Authorization Error: ${env30649[28]?.message || "Unknown Error"}`);
|
|
} catch (r771) {
|
|
r8 = r771;
|
|
c27516_10 = r771;
|
|
r57 = c27516_9;
|
|
if (r57 === 0) {
|
|
break;
|
|
}
|
|
}
|
|
} else if (r57 === 2) {
|
|
try {
|
|
const r748 = c27516_10;
|
|
c27516_9 = 0;
|
|
env30649[29] = r748.body;
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.OAUTH2_ERROR
|
|
}, `OAuth2 Authorize Error: ${env30649[29]?.message || "Unknown Error"}`);
|
|
} catch (r745) {
|
|
r8 = r745;
|
|
c27516_10 = r745;
|
|
r57 = c27516_9;
|
|
if (r57 === 0) {
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
try {
|
|
c27516_9 = 0;
|
|
env30649[31] = void 0;
|
|
if (env30649[20].integration_type != null && Object.values(ApplicationIntegrationType).includes(env30649[20].integration_type)) {
|
|
const map2 = new Map();
|
|
env30649[31] = map2;
|
|
map2.set(env30649[20].integration_type, env30649[20]);
|
|
}
|
|
if (c9428_17[env30649[20].application.id] != null) {
|
|
await c9428_17[env30649[20].application.id].process();
|
|
if (!env30649[15]?.aborted) {
|
|
r502 = (0, env30649[17])({
|
|
clientId: env30649[0],
|
|
authorizations: env30649[31],
|
|
scopes: env30649[23],
|
|
parsedPermissions: env30649[30],
|
|
responseType: env30649[1],
|
|
redirectUri: env30649[2],
|
|
codeChallenge: env30649[3],
|
|
codeChallengeMethod: env30649[4],
|
|
state: env30649[5],
|
|
guildId: env30649[9],
|
|
channelId: env30649[10],
|
|
prompt: env30649[11],
|
|
disableGuildSelect: env30649[12],
|
|
disclosures: env30649[21],
|
|
integrationType: env30649[19],
|
|
pid: env30649[14],
|
|
signal: env30649[15]
|
|
});
|
|
break L57;
|
|
}
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.UNKNOWN_ERROR
|
|
}, "Request aborted");
|
|
}
|
|
r502 = (0, env30649[17])({
|
|
clientId: env30649[0],
|
|
authorizations: env30649[31],
|
|
scopes: env30649[23],
|
|
parsedPermissions: env30649[30],
|
|
responseType: env30649[1],
|
|
redirectUri: env30649[2],
|
|
codeChallenge: env30649[3],
|
|
codeChallengeMethod: env30649[4],
|
|
state: env30649[5],
|
|
guildId: env30649[9],
|
|
channelId: env30649[10],
|
|
prompt: env30649[11],
|
|
disableGuildSelect: env30649[12],
|
|
disclosures: env30649[21],
|
|
integrationType: env30649[19],
|
|
pid: env30649[14],
|
|
signal: env30649[15]
|
|
});
|
|
break L57;
|
|
} catch (r606) {
|
|
r8 = r606;
|
|
c27516_10 = r606;
|
|
r57 = c27516_9;
|
|
if (r57 === 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
throw r8;
|
|
}
|
|
}
|
|
return location2;
|
|
}
|
|
return r502;
|
|
};
|
|
authenticate = function authenticate(a0, a1) {
|
|
const accessToken = a1;
|
|
if (a0.authorization.accessToken) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.INVALID_COMMAND
|
|
}, "Already authenticated");
|
|
}
|
|
if (a0.authorization.authing) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.INVALID_COMMAND
|
|
}, "Already authenticating");
|
|
}
|
|
a0.authorization.authing = true;
|
|
return HTTP.get({
|
|
url: Endpoints.OAUTH2_CURRENT_AUTH,
|
|
headers: {
|
|
Authorization: `Bearer ${a1}`
|
|
},
|
|
oldFormErrors: true,
|
|
rejectWithError: false
|
|
}).then((result) => {
|
|
a0.authorization.authing = false;
|
|
const body = result.body;
|
|
const { application, user, scopes, expires } = body;
|
|
if (a0.application.id !== application.id) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.INVALID_CLIENTID
|
|
}, "Application does not match the connection's");
|
|
}
|
|
const currentUser = UserStore.getCurrentUser();
|
|
if (currentUser != null && user && currentUser.id === user.id) {
|
|
a0.authorization.scopes = [...a0.authorization.scopes, ...scopes, RPC_AUTHENTICATED_SCOPE];
|
|
a0.authorization.accessToken = accessToken;
|
|
a0.authorization.expires = new Date(expires);
|
|
Dispatcher.dispatch({
|
|
type: "RPC_APP_AUTHENTICATED",
|
|
socketId: a0.id,
|
|
application: a0.application
|
|
});
|
|
return {
|
|
...result.body,
|
|
access_token: accessToken
|
|
};
|
|
}
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.INVALID_TOKEN
|
|
}, "Token does not match current user");
|
|
}, () => {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.INVALID_TOKEN
|
|
}, `Invalid access token: ${accessToken}`);
|
|
}).catch((error) => {
|
|
a0.authorization.authing = false;
|
|
throw error;
|
|
});
|
|
};
|
|
c9428_16 = "CachedTokens";
|
|
c9428_17 = {
|
|
"1273616940451102832": new LeakyBucket(2, 1 * Durations.Millis.MINUTE)
|
|
};
|
|
export default function createAuthCommandHandlers(a0, a1) {
|
|
let env20539 = {
|
|
$parent: env9428
|
|
};
|
|
env20539[0] = a0;
|
|
env20539[1] = a1;
|
|
const r11 = {};
|
|
r11[RPCCommands.AUTHENTICATE] = createRPCCommand(RPCCommands.AUTHENTICATE, {
|
|
handler: (a0) => {
|
|
let r51, IDENTIFY;
|
|
let env27517;
|
|
const r6 = env27517 = {
|
|
$parent: env20539
|
|
};
|
|
const socket2 = a0.socket;
|
|
env27517[0] = socket2;
|
|
const signal = a0.signal;
|
|
env27517[1] = signal;
|
|
const access_token = a0.args.access_token;
|
|
env27517[2] = void 0;
|
|
env27517[3] = void 0;
|
|
env27517[4] = void 0;
|
|
if (access_token == null && socket2.transport === TransportTypes.IPC) {
|
|
const id = socket2.application.id;
|
|
env27517[2] = id;
|
|
if (id == null) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.INVALID_COMMAND
|
|
}, "No application.");
|
|
}
|
|
L12: {
|
|
IDENTIFY = OAuth2Scopes.IDENTIFY;
|
|
env27517[3] = IDENTIFY;
|
|
env27517[4] = () => {};
|
|
const r50 = Storage.get(c9428_16);
|
|
const r2 = r50 != null;
|
|
r51 = void 0;
|
|
if (r2) {
|
|
const r53 = r50[id] != null;
|
|
r51 = void 0;
|
|
if (r53) {
|
|
const r54 = r50[id];
|
|
if (r54.scope === IDENTIFY && !(r54.expires <= Date.now())) {
|
|
r51 = r54.accessToken;
|
|
break L12;
|
|
}
|
|
delete r50[id];
|
|
Storage.set(c9428_16, r50);
|
|
r51 = void 0;
|
|
}
|
|
}
|
|
}
|
|
return r51 != null ? authenticate(socket2, r51).catch(() => {
|
|
const r2 = env27517;
|
|
const client_id = env27517[2];
|
|
let r15 = Storage.get(c9428_16);
|
|
if (r15 == null) {
|
|
r15 = {};
|
|
}
|
|
delete r15[client_id];
|
|
Storage.set(c9428_16, r15);
|
|
return authorizeWithPrompt({
|
|
client_id,
|
|
scope: env27517[3],
|
|
response_type: "token",
|
|
signal: env27517[1],
|
|
isSocketRpcPrivateScope: false
|
|
}, env20539[0], env20539[1]).then($mk116551(r2));
|
|
}) : authorizeWithPrompt({
|
|
client_id: id,
|
|
scope: IDENTIFY,
|
|
response_type: "token",
|
|
signal,
|
|
isSocketRpcPrivateScope: false
|
|
}, env20539[0], env20539[1]).then($mk116551(r6));
|
|
}
|
|
if (access_token == null) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.INVALID_TOKEN
|
|
}, "No access token provided");
|
|
}
|
|
return authenticate(socket2, access_token);
|
|
}
|
|
});
|
|
r11[RPCCommands.AUTHORIZE] = {
|
|
handler: ({ socket, signal, args }) => {
|
|
let c27518_1;
|
|
c27518_1 = void 0;
|
|
const client_id = args.client_id;
|
|
if (client_id) {
|
|
if (socket.authorization.accessToken != null) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.INVALID_COMMAND
|
|
}, "Already authenticated");
|
|
}
|
|
if (socket.authorization.authing) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.INVALID_COMMAND
|
|
}, "Already authing");
|
|
}
|
|
socket.authorization.authing = true;
|
|
if (args.response_type === "token") {
|
|
socket.authorization.authing = false;
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.INVALID_COMMAND
|
|
}, "Authorization response_type \"token\" is not supported");
|
|
}
|
|
const isSocketRpcPrivateScope = socket.authorization.scopes.includes(RPC_PRIVATE_SCOPE);
|
|
c27518_1 = isSocketRpcPrivateScope;
|
|
if (!isSocketRpcPrivateScope && socket.application.id !== client_id) {
|
|
socket.authorization.authing = false;
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.INVALID_CLIENTID
|
|
}, "Application does not match the connection's");
|
|
}
|
|
const scope = args.scopes || args.scope;
|
|
delete args["scopes"];
|
|
return authorizeWithPrompt({
|
|
...args,
|
|
scope,
|
|
signal,
|
|
isSocketRpcPrivateScope
|
|
}, env20539[0], env20539[1]).then((result) => {
|
|
socket.authorization.authing = false;
|
|
if (result == null) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.UNKNOWN_ERROR
|
|
}, "Unknown error occurred");
|
|
}
|
|
const uRL = new URL(result);
|
|
const code = uRL.searchParams.get("code");
|
|
if (c27518_1) {
|
|
return {
|
|
code,
|
|
location: result
|
|
};
|
|
}
|
|
const r10 = uRL.searchParams.get("error");
|
|
if (r10 != null && r10 !== "") {
|
|
let r43 = uRL.searchParams.get("error_description");
|
|
if (r43 == null) {
|
|
r43 = "unknown error";
|
|
}
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.OAUTH2_ERROR
|
|
}, `OAuth2 Error: ${r10}: ${r43}`);
|
|
}
|
|
if (code == null) {
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.OAUTH2_ERROR
|
|
}, "OAuth2 Error: Unable to find auth code");
|
|
}
|
|
return {
|
|
code
|
|
};
|
|
}).catch((error) => {
|
|
socket.authorization.authing = false;
|
|
throw error;
|
|
});
|
|
}
|
|
throw new RPCError({
|
|
errorCode: RPCErrors.INVALID_CLIENTID
|
|
}, "No client id provided");
|
|
}
|
|
};
|
|
return r11;
|
|
};
|
|
export { c9428_17 as AUTHORIZE_PROMPT_THROTTLERS };
|