Await for profiles loading before continuing

10ddf77948e0d93af1f14a8ea9801ce8a4b5d397

Cohee <18619528+Cohee1207@users.noreply.github.com>

public/script.js+1 -0 Viewed

     LLM_FUNCTION_TOOL_CALL: 'llm_function_tool_call',
     ONLINE_STATUS_CHANGED: 'online_status_changed',
     IMAGE_SWIPED: 'image_swiped',
+    CONNECTION_PROFILE_LOADED: 'connection_profile_loaded',
 };
 export const eventSource = new EventEmitter();

public/scripts/extensions/connection-manager/index.js+32 -7 Viewed

-import { main_api, saveSettingsDebounced } from '../../../script.js';
+import { event_types, eventSource, main_api, saveSettingsDebounced } from '../../../script.js';
 import { extension_settings, renderExtensionTemplateAsync } from '../../extensions.js';
 import { callGenericPopup, Popup, POPUP_TYPE } from '../../popup.js';
 import { executeSlashCommandsWithOptions } from '../../slash-commands.js';
 import { SlashCommand } from '../../slash-commands/SlashCommand.js';
-import { ARGUMENT_TYPE, SlashCommandArgument } from '../../slash-commands/SlashCommandArgument.js';
+import { ARGUMENT_TYPE, SlashCommandArgument, SlashCommandNamedArgument } from '../../slash-commands/SlashCommandArgument.js';
-import { enumIcons } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';
+import { commonEnumProviders, enumIcons } from '../../slash-commands/SlashCommandCommonEnumsProvider.js';
 import { enumTypes, SlashCommandEnumValue } from '../../slash-commands/SlashCommandEnumValue.js';
 import { SlashCommandParser } from '../../slash-commands/SlashCommandParser.js';
-import { collapseSpaces, getUniqueName, uuidv4 } from '../../utils.js';
+import { collapseSpaces, getUniqueName, isFalseBoolean, uuidv4 } from '../../utils.js';
 const MODULE_NAME = 'connection-manager';
 const NONE = '<None>';

 /** @type {() => SlashCommandEnumValue[]} */
 const profilesProvider = () => [
-    new SlashCommandEnumValue(NONE, NONE),
+    new SlashCommandEnumValue(NONE),
     ...extension_settings.connectionManager.profiles.map(p => new SlashCommandEnumValue(p.name, null, enumTypes.name, enumIcons.server)),
 ];

@@ -155,7 +155,7 @@ async function createConnectionProfile(forceName = null) {
155	return null;	155	return null;
156	}	156	}
157		157
158	if (isNameTaken(name)) {	158	if (isNameTaken(name) \|\| name === NONE) {
159	toastr.error('A profile with the same name already exists.');	159	toastr.error('A profile with the same name already exists.');
160	return null;	160	return null;
161	}	161	}

     profiles.addEventListener('change', async function () {
         const selectedProfile = profiles.selectedOptions[0];
         if (!selectedProfile) {
+            // Safety net for preventing the command getting stuck
+            await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, NONE);
             return;
+        }

         // None option selected
         if (!profileId) {
+            await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, NONE);
             return;
+        }

+        }
         await applyConnectionProfile(profile);
+        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
     });
     const reloadButton = document.getElementById('reload_connection_profile');

+        }
         await applyConnectionProfile(profile);
         await renderDetailsContent(details, detailsContent);
+        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
         toastr.success('Connection profile reloaded', '', { timeOut: 1500 });
     });

         saveSettingsDebounced();
         renderConnectionProfiles(profiles);
         await renderDetailsContent(details, detailsContent);
+        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
     });
     const updateButton = document.getElementById('update_connection_profile');

         await updateConnectionProfile(profile);
         await renderDetailsContent(details, detailsContent);
         saveSettingsDebounced();
+        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, profile.name);
         toastr.success('Connection profile updated', '', { timeOut: 1500 });
     });

         await deleteConnectionProfile();
         renderConnectionProfiles(profiles);
         await renderDetailsContent(details, detailsContent);
+        await eventSource.emit(event_types.CONNECTION_PROFILE_LOADED, NONE);
     });
     /** @type {HTMLDetailsElement} */

                 isRequired: false,
             }),
         ],
-        callback: async (_args, value) => {
+        namedArgumentList: [
+            SlashCommandNamedArgument.fromProps({
+                name: 'await',
+                description: 'Wait for the connection profile to be applied before returning.',
+                isRequired: false,
+                typeList: [ARGUMENT_TYPE.BOOLEAN],
+                defaultValue: 'true',
+                enumList: commonEnumProviders.boolean('trueFalse')(),
+            }),
+        ],
+        callback: async (args, value) => {
             if (!value || typeof value !== 'string') {
                 const selectedProfile = extension_settings.connectionManager.selectedProfile;
                 const profile = extension_settings.connectionManager.profiles.find(p => p.id === selectedProfile);

                 return '';
+            }
+            const shouldAwait = !isFalseBoolean(String(args?.await));
+            const awaitPromise = new Promise((resolve) => eventSource.once(event_types.CONNECTION_PROFILE_LOADED, resolve));
             profiles.selectedIndex = Array.from(profiles.options).findIndex(o => o.value === profile.id);
             profiles.dispatchEvent(new Event('change'));
+            if (shouldAwait) {
+                await awaitPromise;
+            }
             return profile.name;
         },
     }));