casualos 3.4.6-alpha.14601027727 → 3.5.0-alpha.15117651144

package/cli.js

@@ -1,19 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
 /* CasualOS is a set of web-based tools designed to facilitate the creation of real-time, multi-user, context-aware interactive experiences.
  *
  * Copyright (c) 2019-2025 Casual Simulation, Inc.
@@ -33,13 +17,14 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
  */
 import prompts from 'prompts';
 import { Command } from 'commander';
+/* eslint-disable casualos/no-non-type-imports */
 import { createRecordsClient } from '@casual-simulation/aux-records/RecordsClient';
 import { askForInputs, onState } from './schema';
 import repl from 'node:repl';
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import Conf from 'conf';
-import { getSessionKeyExpiration, isExpired, parseSessionKey, willExpire, } from '@casual-simulation/aux-records/AuthUtils';
+import { getSessionKeyExpiration, isExpired, parseSessionKey, willExpire, } from '@casual-simulation/aux-common';
 import { serverConfigSchema } from '@casual-simulation/aux-records';
 import { PassThrough } from 'node:stream';
 import { getSchemaMetadata } from '@casual-simulation/aux-common';
@@ -59,35 +44,35 @@ program
 program
     .command('login')
     .description('Login to the CasualOS API')
-    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    .action(async () => {
     const opts = program.optsWithGlobals();
-    const endpoint = yield getEndpoint(opts.endpoint);
-    const client = yield getClient(endpoint, getSessionKey(endpoint));
-    yield login(client);
-}));
+    const endpoint = await getEndpoint(opts.endpoint);
+    const client = await getClient(endpoint, getSessionKey(endpoint));
+    await login(client);
+});
 program
     .command('logout')
     .description('Logout of the CasualOS API')
-    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    .action(async () => {
     const opts = program.optsWithGlobals();
-    const endpoint = yield getEndpoint(opts.endpoint);
+    const endpoint = await getEndpoint(opts.endpoint);
     saveSessionKey(endpoint, null);
     console.log('Logged out!');
-}));
+});
 program
     .command('set-endpoint')
     .argument('[endpoint]', 'The endpoint to use for queries. If omitted, then you will be prompted to enter an endpoint.')
     .description('Set the endpoint that is currently in use.')
-    .action((endpoint) => __awaiter(void 0, void 0, void 0, function* () {
+    .action(async (endpoint) => {
     if (endpoint) {
         saveCurrentEndpoint(endpoint);
     }
     else {
-        endpoint = yield updateEndpoint();
+        endpoint = await updateEndpoint();
     }
     const origin = getOrigin(endpoint);
     if (origin !== endpoint) {
-        const response = yield prompts({
+        const response = await prompts({
             type: 'confirm',
             name: 'confirm',
             message: `The origin for the endpoint (${origin}) is different from the endpoint (${endpoint}) itself. Do you want to keep it?`,
@@ -98,7 +83,7 @@ program
             return;
         }
     }
-    const originResponse = yield prompts({
+    const originResponse = await prompts({
         type: 'text',
         name: 'origin',
         message: 'Enter the origin to use for requests to this endpoint.',
@@ -106,38 +91,38 @@ program
         onState,
     });
     saveOrigin(endpoint, originResponse.origin);
-}));
+});
 program
     .command('status')
     .description('Get the status of the current session.')
-    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    .action(async () => {
     const endpoint = getCurrentEndpoint();
     printStatus(endpoint);
-}));
+});
 program
     .command('query')
     .description('Query the CasualOS API')
     .argument('[procedure]', 'The procedure to execute. If omitted, then you will be prompted to select a procedure.')
     .argument('[input]', 'The input to the procedure. If specified, then it will be parsed as JSON. If omitted, then you will be prompted to enter the input.')
     .option('-k, --key <key>', 'The session key to use for the query. If not specified, then the current session key will be used.')
-    .action((procedure, input, options) => __awaiter(void 0, void 0, void 0, function* () {
+    .action(async (procedure, input, options) => {
     var _a;
     const opts = program.optsWithGlobals();
-    const endpoint = yield getEndpoint(opts.endpoint);
-    const client = yield getClient(endpoint, (_a = opts.key) !== null && _a !== void 0 ? _a : (yield getOrRefreshSessionKey(endpoint)));
-    yield query(client, procedure, input);
-}));
+    const endpoint = await getEndpoint(opts.endpoint);
+    const client = await getClient(endpoint, (_a = opts.key) !== null && _a !== void 0 ? _a : (await getOrRefreshSessionKey(endpoint)));
+    await query(client, procedure, input);
+});
 program
     .command('repl')
     .description('Start a REPL for the CasualOS API')
     .option('-k, --key <key>', 'The session key to use for the session. If omitted, then the current session key will be used.')
     .addHelpText('after', `\nThe CasualOS REPL allows you to interact with the CasualOS API using a Read-Eval-Print Loop (REPL).\nIt supports JavaScript and has a special function, query([procedure], [input]), that can be used to query the API.`)
-    .action((options) => __awaiter(void 0, void 0, void 0, function* () {
-    var _b;
+    .action(async (options) => {
+    var _a;
     const opts = program.optsWithGlobals();
-    const endpoint = yield getEndpoint(opts.endpoint);
-    const key = (_b = opts.key) !== null && _b !== void 0 ? _b : (yield getOrRefreshSessionKey(endpoint));
-    const client = yield getClient(endpoint, key);
+    const endpoint = await getEndpoint(opts.endpoint);
+    const key = (_a = opts.key) !== null && _a !== void 0 ? _a : (await getOrRefreshSessionKey(endpoint));
+    const client = await getClient(endpoint, key);
     let userId = null;
     if (key) {
         const parseResult = parseSessionKey(key);
@@ -148,17 +133,17 @@ program
     const replIn = new PassThrough();
     process.stdin.pipe(replIn);
     function pauseRepl(func) {
-        return (...args) => __awaiter(this, void 0, void 0, function* () {
+        return async (...args) => {
             process.stdin.unpipe(replIn);
             replIn.pause();
             try {
-                return yield func(...args);
+                return await func(...args);
             }
             finally {
                 replIn.resume();
                 process.stdin.pipe(replIn);
             }
-        });
+        };
     }
     const replServer = repl.start({
         prompt: 'casualos > ',
@@ -173,9 +158,9 @@ program
             configurable: false,
             writable: false,
             enumerable: true,
-            value: pauseRepl((procedure, input) => __awaiter(void 0, void 0, void 0, function* () {
-                return yield query(client, procedure, input, false, true, replServer);
-            })),
+            value: pauseRepl(async (procedure, input) => {
+                return await query(client, procedure, input, false, true, replServer);
+            }),
         },
         userId: {
             configurable: false,
@@ -184,14 +169,14 @@ program
             value: userId,
         },
     });
-}));
+});
 program
     .command('generate-server-config')
     .option('-p, --pretty', 'Pretty print the output.')
     .description('Generate a server config for CasualOS.')
-    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    .action(async () => {
     const metadata = getSchemaMetadata(serverConfigSchema);
-    const result = yield askForInputs(metadata, 'serverConfig');
+    const result = await askForInputs(metadata, 'serverConfig');
     const isValid = serverConfigSchema.safeParse(result);
     if (isValid.success === false) {
         console.error('Generated config is invalid:');
@@ -204,20 +189,20 @@ program
     else {
         console.log(JSON.stringify(result));
     }
-}));
+});
 program
     .command('validate-server-config')
     .option('--json <config>', 'The JSON to validate.')
     .option('-f, --file <file>', 'The file to validate.')
     .description('Validate a server config for CasualOS.')
-    .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+    .action(async (options) => {
     let configJson;
     if (options.json) {
         configJson = options.json;
     }
     else {
         const fullPath = path.resolve(options.file);
-        configJson = yield readFile(fullPath, 'utf-8');
+        configJson = await readFile(fullPath, 'utf-8');
     }
     const parsed = JSON.parse(configJson);
     const result = serverConfigSchema.safeParse(parsed);
@@ -229,154 +214,131 @@ program
         console.error(result.error.toString());
         process.exit(1);
     }
-}));
+});
 setupInfraCommands(program.command('infra'), config);
-function query(client, procedure, input, shouldConfirm = true, isJavaScriptInput = false, repl = null) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const availableOperations = yield client.listProcedures({});
-        while (!procedure ||
-            !availableOperations.procedures.find((p) => p.name === procedure)) {
-            const response = yield prompts({
-                type: 'autocomplete',
-                name: 'procedure',
-                message: 'Select the procedure to execute',
-                choices: availableOperations.procedures.map((op) => ({
-                    title: op.name,
-                    value: op.name,
-                })),
-                onState,
-            });
-            procedure = response.procedure;
-        }
-        const operation = availableOperations.procedures.find((p) => p.name === procedure);
-        if (!operation) {
-            console.error(`Could not find operation ${procedure}!`);
-            return;
-        }
-        console.log('Your selected operation:', operation);
-        let query;
-        if (operation.query) {
-            query = yield askForInputs(operation.query, operation.name, repl);
-            console.log('Your query:', query);
-        }
-        if (!input) {
-            input = yield askForInputs(operation.inputs, operation.name, repl);
-        }
-        else if (!isJavaScriptInput) {
-            input = JSON.parse(input);
-        }
-        console.log('Your input:', input);
-        let continueRequest = true;
+async function query(client, procedure, input, shouldConfirm = true, isJavaScriptInput = false, repl = null) {
+    const availableOperations = await client.listProcedures({});
+    while (!procedure ||
+        !availableOperations.procedures.find((p) => p.name === procedure)) {
+        const response = await prompts({
+            type: 'autocomplete',
+            name: 'procedure',
+            message: 'Select the procedure to execute',
+            choices: availableOperations.procedures.map((op) => ({
+                title: op.name,
+                value: op.name,
+            })),
+            onState,
+        });
+        procedure = response.procedure;
+    }
+    const operation = availableOperations.procedures.find((p) => p.name === procedure);
+    if (!operation) {
+        console.error(`Could not find operation ${procedure}!`);
+        return;
+    }
+    console.log('Your selected operation:', operation);
+    let query;
+    if (operation.query) {
+        query = await askForInputs(operation.query, operation.name, repl);
+        console.log('Your query:', query);
+    }
+    if (!input) {
+        input = await askForInputs(operation.inputs, operation.name, repl);
+    }
+    else if (!isJavaScriptInput) {
+        input = JSON.parse(input);
+    }
+    console.log('Your input:', input);
+    let continueRequest = true;
+    if (shouldConfirm) {
+        const confirm = await prompts({
+            type: 'confirm',
+            name: 'continue',
+            message: 'Do you want to continue?',
+            initial: true,
+            onState,
+        });
+        continueRequest = confirm.continue;
+    }
+    if (continueRequest) {
+        const result = await callProcedure(client, operation.name, input, query);
         if (shouldConfirm) {
-            const confirm = yield prompts({
-                type: 'confirm',
-                name: 'continue',
-                message: 'Do you want to continue?',
-                initial: true,
-                onState,
-            });
-            continueRequest = confirm.continue;
-        }
-        if (continueRequest) {
-            const result = yield callProcedure(client, operation.name, input, query);
-            if (shouldConfirm) {
-                if (typeof result === 'object' && Symbol.asyncIterator in result) {
-                    console.log('Result:');
-                    function logResult() {
-                        var _a, e_1, _b, _c;
-                        return __awaiter(this, void 0, void 0, function* () {
-                            try {
-                                for (var _d = true, result_1 = __asyncValues(result), result_1_1; result_1_1 = yield result_1.next(), _a = result_1_1.done, !_a; _d = true) {
-                                    _c = result_1_1.value;
-                                    _d = false;
-                                    let item = _c;
-                                    console.log(item);
-                                }
-                            }
-                            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                            finally {
-                                try {
-                                    if (!_d && !_a && (_b = result_1.return)) yield _b.call(result_1);
-                                }
-                                finally { if (e_1) throw e_1.error; }
-                            }
-                        });
+            if (typeof result === 'object' && Symbol.asyncIterator in result) {
+                console.log('Result:');
+                async function logResult() {
+                    for await (let item of result) {
+                        console.log(item);
                     }
-                    logResult();
-                }
-                else {
-                    console.log('Result:', result);
                 }
+                logResult();
+            }
+            else {
+                console.log('Result:', result);
             }
-            return result;
-        }
-        else {
-            console.log('Cancelled.');
         }
-    });
+        return result;
+    }
+    else {
+        console.log('Cancelled.');
+    }
 }
-function callProcedure(client, operation, input, query) {
-    return __awaiter(this, void 0, void 0, function* () {
-        while (true) {
-            const result = yield client.callProcedure(operation, input, {
-                headers: getHeaders(client),
-            }, query);
-            if (result.success === false && result.errorCode === 'not_logged_in') {
-                const loginResponse = yield prompts({
-                    type: 'confirm',
-                    name: 'login',
-                    message: 'You are not logged in. Do you want to log in and try again?',
-                    initial: true,
-                    onState,
-                });
-                if (loginResponse.login) {
-                    const key = yield login(client);
-                    if (!key) {
-                        return result;
-                    }
-                }
-                else {
+async function callProcedure(client, operation, input, query) {
+    while (true) {
+        const result = await client.callProcedure(operation, input, {
+            headers: getHeaders(client),
+        }, query);
+        if (result.success === false && result.errorCode === 'not_logged_in') {
+            const loginResponse = await prompts({
+                type: 'confirm',
+                name: 'login',
+                message: 'You are not logged in. Do you want to log in and try again?',
+                initial: true,
+                onState,
+            });
+            if (loginResponse.login) {
+                const key = await login(client);
+                if (!key) {
                     return result;
                 }
             }
-            else if (result.success === false &&
-                result.errorCode === 'invalid_origin') {
-                const originResponse = yield prompts({
-                    type: 'text',
-                    name: 'origin',
-                    message: 'The endpoint does not allow itself as an origin. Enter the origin to use for the request.',
-                    onState,
-                });
-                saveOrigin(client.endpoint, originResponse.origin);
-            }
             else {
                 return result;
             }
         }
-    });
-}
-function getClient(endpoint, key) {
-    return __awaiter(this, void 0, void 0, function* () {
-        printStatus(endpoint);
-        const client = createRecordsClient(endpoint);
-        if (key) {
-            client.sessionKey = key;
-        }
-        return client;
-    });
-}
-function getOrRefreshSessionKey(endpoint) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const key = getSessionKey(endpoint);
-        const expiration = getSessionKeyExpiration(key);
-        if (isExpired(expiration)) {
-            return null;
+        else if (result.success === false &&
+            result.errorCode === 'invalid_origin') {
+            const originResponse = await prompts({
+                type: 'text',
+                name: 'origin',
+                message: 'The endpoint does not allow itself as an origin. Enter the origin to use for the request.',
+                onState,
+            });
+            saveOrigin(client.endpoint, originResponse.origin);
         }
-        else if (willExpire(expiration)) {
-            return yield replaceSessionKey(endpoint, key);
+        else {
+            return result;
         }
-        return key;
-    });
+    }
+}
+async function getClient(endpoint, key) {
+    printStatus(endpoint);
+    const client = createRecordsClient(endpoint);
+    if (key) {
+        client.sessionKey = key;
+    }
+    return client;
+}
+async function getOrRefreshSessionKey(endpoint) {
+    const key = getSessionKey(endpoint);
+    const expiration = getSessionKeyExpiration(key);
+    if (isExpired(expiration)) {
+        return null;
+    }
+    else if (willExpire(expiration)) {
+        return await replaceSessionKey(endpoint, key);
+    }
+    return key;
 }
 function getSessionKey(endpoint) {
     return convertToString(config.get(`${endpoint}:sessionKey`));
@@ -394,179 +356,167 @@ function saveLoginResult(client, result) {
         client.sessionKey = result.sessionKey;
     }
 }
-function login(client) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const response = yield prompts([
-            {
-                type: 'select',
-                name: 'type',
-                message: 'Select the type of address to use for login.',
-                choices: [
-                    {
-                        title: 'Email',
-                        value: 'email',
-                    },
-                    {
-                        title: 'Phone',
-                        value: 'phone',
-                    },
-                    {
-                        title: 'Privo',
-                        value: 'privo',
-                    },
-                ],
-                onState,
-            },
-        ]);
-        if (response.type === 'privo') {
-            return yield loginWithPrivo(client);
-        }
-        else if (response.type === 'email' || response.type === 'phone') {
-            const addressResponse = yield prompts({
-                type: 'text',
-                name: 'address',
-                message: 'Enter your address.',
-                onState,
-            });
-            const addressType = response.type;
-            const address = addressResponse.address;
-            return yield loginWithCode(client, address, addressType);
-        }
-    });
+async function login(client) {
+    const response = await prompts([
+        {
+            type: 'select',
+            name: 'type',
+            message: 'Select the type of address to use for login.',
+            choices: [
+                {
+                    title: 'Email',
+                    value: 'email',
+                },
+                {
+                    title: 'Phone',
+                    value: 'phone',
+                },
+                {
+                    title: 'Privo',
+                    value: 'privo',
+                },
+            ],
+            onState,
+        },
+    ]);
+    if (response.type === 'privo') {
+        return await loginWithPrivo(client);
+    }
+    else if (response.type === 'email' || response.type === 'phone') {
+        const addressResponse = await prompts({
+            type: 'text',
+            name: 'address',
+            message: 'Enter your address.',
+            onState,
+        });
+        const addressType = response.type;
+        const address = addressResponse.address;
+        return await loginWithCode(client, address, addressType);
+    }
 }
-function loginWithCode(client, address, addressType) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const result = yield client.requestLogin({
-            address: address,
-            addressType: addressType,
+async function loginWithCode(client, address, addressType) {
+    const result = await client.requestLogin({
+        address: address,
+        addressType: addressType,
+    }, {
+        headers: getHeaders(client),
+    });
+    if (result.success) {
+        const response = await prompts({
+            type: 'text',
+            name: 'code',
+            message: 'Enter the code that was sent to your address.',
+            onState,
+        });
+        const code = response.code;
+        const loginResult = await client.completeLogin({
+            code: code,
+            requestId: result.requestId,
+            userId: result.userId,
         }, {
             headers: getHeaders(client),
         });
-        if (result.success) {
-            const response = yield prompts({
-                type: 'text',
-                name: 'code',
-                message: 'Enter the code that was sent to your address.',
-                onState,
-            });
-            const code = response.code;
-            const loginResult = yield client.completeLogin({
-                code: code,
-                requestId: result.requestId,
-                userId: result.userId,
-            }, {
-                headers: getHeaders(client),
-            });
-            if (loginResult.success === true) {
-                saveLoginResult(client, loginResult);
-                console.log('Login successful!');
-                return loginResult.sessionKey;
-            }
-            else {
-                saveLoginResult(client, null);
-                console.log('Failed to complete login:');
-                console.log(loginResult);
-                return null;
-            }
+        if (loginResult.success === true) {
+            saveLoginResult(client, loginResult);
+            console.log('Login successful!');
+            return loginResult.sessionKey;
         }
         else {
             saveLoginResult(client, null);
-            console.log('Failed to create login request:');
-            console.log(result);
+            console.log('Failed to complete login:');
+            console.log(loginResult);
             return null;
         }
-    });
+    }
+    else {
+        saveLoginResult(client, null);
+        console.log('Failed to create login request:');
+        console.log(result);
+        return null;
+    }
 }
-function loginWithPrivo(client) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const result = yield client.requestPrivoLogin({}, {
+async function loginWithPrivo(client) {
+    const result = await client.requestPrivoLogin({}, {
+        headers: getHeaders(client),
+    });
+    if (result.success === false) {
+        saveLoginResult(client, null);
+        console.log('Failed to request Privo login:');
+        console.log(result);
+        return null;
+    }
+    const open = (await import('open')).default;
+    await open(result.authorizationUrl);
+    const startTime = Date.now();
+    const timeout = 1000 * 60 * 5; // 5 minutes
+    while (Date.now() - startTime < timeout) {
+        const loginResult = await client.completeOAuthLogin({
+            requestId: result.requestId,
+        }, {
             headers: getHeaders(client),
         });
-        if (result.success === false) {
-            saveLoginResult(client, null);
-            console.log('Failed to request Privo login:');
-            console.log(result);
-            return null;
+        if (loginResult.success === true) {
+            saveLoginResult(client, loginResult);
+            console.log('Login successful!');
+            return loginResult.sessionKey;
         }
-        const open = (yield import('open')).default;
-        yield open(result.authorizationUrl);
-        const startTime = Date.now();
-        const timeout = 1000 * 60 * 5; // 5 minutes
-        while (Date.now() - startTime < timeout) {
-            const loginResult = yield client.completeOAuthLogin({
-                requestId: result.requestId,
-            }, {
-                headers: getHeaders(client),
-            });
-            if (loginResult.success === true) {
-                saveLoginResult(client, loginResult);
-                console.log('Login successful!');
-                return loginResult.sessionKey;
+        else {
+            if (loginResult.errorCode === 'not_completed') {
+                // Wait for a second before trying again.
+                await new Promise((resolve) => setTimeout(resolve, 1000));
             }
             else {
-                if (loginResult.errorCode === 'not_completed') {
-                    // Wait for a second before trying again.
-                    yield new Promise((resolve) => setTimeout(resolve, 1000));
-                }
-                else {
-                    saveLoginResult(client, null);
-                    console.log('Failed to complete login:');
-                    console.log(loginResult);
-                    return null;
-                }
+                saveLoginResult(client, null);
+                console.log('Failed to complete login:');
+                console.log(loginResult);
+                return null;
             }
         }
-        saveLoginResult(client, null);
-        console.log('Failed to complete login:');
-        console.log('Timed out');
-        return null;
-    });
+    }
+    saveLoginResult(client, null);
+    console.log('Failed to complete login:');
+    console.log('Timed out');
+    return null;
 }
-function replaceSessionKey(endpoint, key) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const client = yield getClient(endpoint, key);
-        const result = yield client.replaceSession(undefined, {
-            sessionKey: key,
-        });
-        if (result.success === true) {
-            saveSessionKey(endpoint, result.sessionKey);
-            console.log('Session key replaced!');
-            return result.sessionKey;
-        }
-        saveSessionKey(endpoint, null);
-        console.log('Failed to replace session key:');
-        console.log(result);
-        return null;
+async function replaceSessionKey(endpoint, key) {
+    const client = await getClient(endpoint, key);
+    const result = await client.replaceSession(undefined, {
+        sessionKey: key,
     });
+    if (result.success === true) {
+        saveSessionKey(endpoint, result.sessionKey);
+        console.log('Session key replaced!');
+        return result.sessionKey;
+    }
+    saveSessionKey(endpoint, null);
+    console.log('Failed to replace session key:');
+    console.log(result);
+    return null;
 }
-function getEndpoint(endpoint) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (endpoint) {
-            return endpoint;
-        }
-        let savedEndpoint = getCurrentEndpoint();
-        console.log('saved endpoint', savedEndpoint);
-        if (!savedEndpoint) {
-            savedEndpoint = yield updateEndpoint();
-        }
-        return savedEndpoint;
-    });
+async function getEndpoint(endpoint) {
+    if (endpoint) {
+        return endpoint;
+    }
+    let savedEndpoint = getCurrentEndpoint();
+    console.log('saved endpoint', savedEndpoint);
+    if (!savedEndpoint) {
+        savedEndpoint = await updateEndpoint();
+    }
+    return savedEndpoint;
 }
 function getCurrentEndpoint() {
     return convertToString(config.get('currentEndpoint'));
 }
-function updateEndpoint() {
-    return __awaiter(this, void 0, void 0, function* () {
-        const response = yield prompts({
-            type: 'text',
-            name: 'endpoint',
-            message: 'Enter the endpoint to use for queries.',
-            onState,
-        });
-        const savedEndpoint = response.endpoint;
-        saveCurrentEndpoint(savedEndpoint);
-        return savedEndpoint;
+async function updateEndpoint() {
+    const response = await prompts({
+        type: 'text',
+        name: 'endpoint',
+        message: 'Enter the endpoint to use for queries.',
+        onState,
     });
+    const savedEndpoint = response.endpoint;
+    saveCurrentEndpoint(savedEndpoint);
+    return savedEndpoint;
 }
 function saveCurrentEndpoint(endpoint) {
     config.set('currentEndpoint', endpoint);
@@ -609,15 +559,13 @@ function printStatus(endpoint) {
         console.log('You are not logged in.');
     }
 }
-function main() {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            yield program.parseAsync(process.argv);
-        }
-        catch (err) {
-            console.error(err);
-        }
-    });
+async function main() {
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (err) {
+        console.error(err);
+    }
 }
 function convertToString(str) {
     if (typeof str === 'undefined' || str === null) {