Skip to content

SmythOS Studio: Open-Source Visual AI Agent Builder and deployable runtime stack from SmythOS. Start with an intuitive drag-and-drop workspace, extend with custom code, and deploy your agents anywhere — local, cloud, or edge — with full governance and control.

11.6 KB
Raw Blame
import { lsCache } from '../../shared/Cache.class';
import { ERR_MSG_VAULT_KEY_NAME, VAULT_DATA_CACHE_KEY } from '../../shared/constants/general';
import { generateKeyTemplateVar } from '../../shared/utils';
import config, { COMP_NAMES, EXTENSION_COMP_NAMES } from '../config';
import { editValues } from '../ui/dialogs';
import { dispatchInputEvent } from './form.utils';
import { createSpinner, getSelectedText, isTemplateVariable } from './general.utils';

const uiServer = config.env.UI_SERVER;

export const isKeyTemplateVariable = (str: string): boolean => {
  if (!str) return false;

  const pattern = /{{KEY\((.*?)\)}}/;

  const match = str.match(pattern);

  if (!match) return false;

  return true;
};

export const getKeyIdsFromTemplateVars = (str: string): string[] => {
  if (!str) return [];

  const pattern = /{{KEY\((.*?)\)}}/g;
  const keyIds = [];
  let match = [];

  while ((match = pattern.exec(str)) !== null) {
    if (match?.length < 2) continue;
    keyIds.push(match[1]);
  }

  return keyIds;
};

async function _ensureUniqueKeyName(keyName: string) {
  const isKeyExistsResponse = await fetch(`/api/page/builder/keys/prefix/${keyName}/exists`).then(
    (res) => res.json(),
  );

  const isKeyExists = isKeyExistsResponse?.data?.exists;

  if (isKeyExists) {
    const keyIndex = isKeyExistsResponse?.data?.highestIndex;

    return `${keyName}_${keyIndex + 1}`;
  }

  return keyName;
}

export const addVaultKey = async (
  scope: string,
  key?: string,
  keyName?: string,
): Promise<{ keyId: string; keyName: string }> => {
  try {
    const fields = {};
    let label = 'Key';
    let _keyName = keyName || '';

    if (!_keyName) {
      if (scope.includes(EXTENSION_COMP_NAMES.zapierAction)) {
        const credentialsUrl = 'https://actions.zapier.com/credentials/';
        fields['fields'] = {
          type: 'div',
          html: `If you don't have the API key, get it from <a href="${credentialsUrl}" target="_blank" class="inner-link">here</a>`,
          cls: 'bg-transparent border-0 p-0 m-0',
        };
        label = 'Zapier AI Actions API Key';
        _keyName = `ZAPIER_AI_ACTIONS_API_KEY`;
      } else if (scope.includes(EXTENSION_COMP_NAMES.huggingFaceModel)) {
        label = 'Hugging Face Access Token';
        _keyName = `HUGGING_FACE_ACCESS_TOKEN`;
      } else if (scope.includes(COMP_NAMES.apiCall)) {
        label = 'API Key';
        _keyName = `API_KEY`;
      } else {
        _keyName = `KEY`;
      }
    }

    _keyName = await _ensureUniqueKeyName(_keyName);

    const values = (await editValues({
      title: `Save ${label} to the Vault`,
      entriesObject: {
        keyName: {
          type: 'text',
          label: 'Name',
          classOverride: 'p-2 w-full',
          validate: `required maxlength=300 custom=validVaultKeyName`,
          smythValidate: 'func=isUniqueVaultKeyName', // as Metro UI does not support async function
          validateMessage: ERR_MSG_VAULT_KEY_NAME,
          value: _keyName,
        },
        apiKey: {
          type: 'textarea',
          label: 'Key',
          fieldCls: 'max-h-64 min-h-[34px] px-3 py-1 resize-y',
          classOverride: 'p-2 w-full',
          validate: 'required maxlength=10000',
          validateMessage: `Please provide a valid ${label} that is not empty and is less than 10000 characters.`,
          value: key || '',
          attributes: { 'data-auto-size': 'false', style: 'height: 34px;' }, // 'data-auto-size': 'false' to prevent set auto height initially
        },
        ...fields,
      },
      secondary: true,
    })) as { keyName: string; apiKey: string };

    if (values?.apiKey) {
      const saveKey = await fetch(`${uiServer}/api/page/builder/keys`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          keyName: values?.keyName,
          key: values?.apiKey,
          scope: scope.split(','),
        }),
      }).then((res) => res.json());

      if (saveKey?.data?.keyId) {
        lsCache.delete(VAULT_DATA_CACHE_KEY);
        return {
          keyId: saveKey?.data?.keyId,
          keyName: values?.keyName,
        };
      }
    }
  } catch {
    return {
      keyId: '',
      keyName: '',
    };
  }
};

const _fetchKeys = async () => {
  try {
    let url = `/api/page/builder/keys?fields=name,scope`;

    const res = await fetch(url);
    const resJson = await res.json();

    return resJson?.data || {};
  } catch {
    return {};
  }
};

// TODO [Forhad]: Need adjust why 'All' returns keys that includes 'All' Scope. When the scope is 'All' we should return all keys without checking the scope.
export const getVaultData = async ({
  scope,
  ignoreCache,
  keyId,
}: {
  scope: string;
  ignoreCache?: boolean;
  keyId?: string;
}) => {
  let vaultData = {};
  let data = {};
  let source = 'cache';

  if (!ignoreCache) {
    vaultData = lsCache.get(VAULT_DATA_CACHE_KEY) || {};
  }

  if (!Object.keys(vaultData).length) {
    vaultData = await _fetchKeys();

    source = 'server';

    lsCache.set(VAULT_DATA_CACHE_KEY, vaultData);
  }

  if (Object.keys(vaultData)?.length) {
    for (const keyId in vaultData) {
      const keyObj = vaultData[keyId];

      if (
        !scope || // Will return all keys if scope is not defined
        (scope?.includes('ALL_NON_GLOBAL_KEYS') && !keyObj?.scope?.includes('global')) ||
        scope?.split(',')?.some((s) => keyObj?.scope?.includes(s)) // Sometimes we have multiple scopes like 'HuggingFace,All' etc.
      ) {
        data[keyId] = keyObj;
      }
    }
  }

  if (keyId && typeof keyId === 'string') {
    return { data: data?.[keyId], source };
  }

  return { data, source };
};

export function updateVaultDataCache(vaultData: any) {
  const currentVaultData = lsCache.get(VAULT_DATA_CACHE_KEY) || {};
  lsCache.set(VAULT_DATA_CACHE_KEY, { ...currentVaultData, ...vaultData });
}

export const insertKeyTemplateVar = (
  fieldElm: HTMLInputElement | HTMLTextAreaElement,
  keyVar: string,
) => {
  if (fieldElm.getAttribute('data-vault-exclusive') === 'true') {
    // Focus on the textarea again.
    fieldElm.focus();

    dispatchInputEvent(fieldElm); // help to resolve 'required' validation issue, as the value is updated programmatically

    fieldElm.value = keyVar;
  } else {
    // Get the start and end positions of the cursor.
    const startPosition = fieldElm.selectionStart;
    const endPosition = fieldElm.selectionEnd;

    // Focus on the textarea again.
    fieldElm.focus();

    dispatchInputEvent(fieldElm); // help to resolve 'required' validation issue, as the value is updated programmatically

    // Set the cursor position to the end of the text.
    const cursorPosition = startPosition + keyVar?.length || 0;
    fieldElm.setSelectionRange(cursorPosition, cursorPosition);

    if (!fieldElm?.value?.includes(keyVar)) {
      fieldElm.value = `${fieldElm.value.substring(
        0,
        startPosition,
      )}${keyVar}${fieldElm.value.substring(endPosition)}`;
    }
  }
};

export const createKeyBtnItems = async (
  targetField: HTMLInputElement,
  sync?: boolean,
): Promise<{
  keyBtns: HTMLAnchorElement[];
  source: string;
}> => {
  let keyBtns = [];
  const fieldValue = targetField?.value || '';

  const vaultBtn = targetField?.closest('.form-group')?.querySelector('.vault-action-btn');

  // show spinner when fetching keys from the server, but not when syncing
  if (!sync) {
    // show spinner when fetching keys from the server
    const spinner = createSpinner('grey', 'mt-[-3px]');
    vaultBtn.appendChild(spinner);
  }

  const scope = targetField.getAttribute('data-vault') || 'All';

  let { data, source } = await getVaultData({ scope, ignoreCache: sync });

  if (!sync) {
    vaultBtn.querySelector('.smyth-spinner')?.remove();
  }

  for (const keyId in data) {
    const keyName = data[keyId]?.name || keyId;
    const btn = document.createElement('a');
    btn.setAttribute('href', '#');
    btn.setAttribute('data-value', keyId);
    btn.textContent = keyName;

    const existingKeyNames = getKeyIdsFromTemplateVars(fieldValue) || [];

    for (const existingKeyName of existingKeyNames) {
      if (existingKeyName === keyName) {
        btn.classList.add('active');
      }
    }

    const keyVar = generateKeyTemplateVar(keyName);

    btn.onclick = (event) => {
      event.preventDefault();

      if (targetField?.classList?.contains('json-editor')) {
        const editor = (<any>targetField)?._editor;

        editor.session.replace(editor?.selection?.getRange(), keyVar);

        // Set the cursor to the new position
        editor?.moveCursorToPosition(editor?.getCursorPosition());

        editor?.focus();

        dispatchInputEvent(editor);
      } else {
        insertKeyTemplateVar(targetField, keyVar);
      }
    };

    keyBtns.push(btn);
  }

  return { keyBtns, source };
};

const _innerLink = (targetField: HTMLInputElement, message: string = '', keyName?: string) => {
  const msgElm = document.createElement('div');
  msgElm.style.padding = '10px';

  const linkElm = document.createElement('button');
  //linkElm.setAttribute('href', '#');
  linkElm.classList.add('inner-link');
  linkElm.innerText = ' Add Key ';

  if (message) {
    msgElm.append(message);
  }

  msgElm.append(linkElm);
  //msgElm.append(', to add a key');

  linkElm.addEventListener('click', async (event) => {
    event.preventDefault();
    const target = event.target as HTMLAnchorElement;

    let formGroup = target?.closest('.form-group');
    if (!formGroup) {
      const dropdown = target?.closest('#vault-keys-dropdown-menu');

      formGroup = dropdown?.['relFormGroup'];
    }
    const actionBtn = formGroup.querySelector('.field-action-btn') as HTMLButtonElement;

    const spinner = createSpinner('grey');
    actionBtn.appendChild(spinner);
    actionBtn.disabled = true;

    const existingDropdown = document.getElementById('vault-keys-dropdown-menu');
    if (existingDropdown) {
      existingDropdown.remove();
    }

    try {
      let selectedText = '';

      if (targetField?.classList?.contains('json-editor')) {
        const editor = (<any>targetField)?._editor;
        selectedText = editor?.getSelectedText();
      } else {
        selectedText = getSelectedText(targetField);
      }

      const key = !(isKeyTemplateVariable(selectedText) || isTemplateVariable(selectedText))
        ? selectedText
        : '';

      const scope = targetField.getAttribute('data-vault') || 'All';
      const result = await addVaultKey(scope, key, keyName);

      if (result?.keyId) {
        const keyVar = generateKeyTemplateVar(result?.keyName);
        insertKeyTemplateVar(targetField, keyVar);
      }
    } catch {
      console.log('Error adding vault key');
    } finally {
      spinner.remove();
      actionBtn.disabled = false;
    }
  });

  return msgElm;
};

export const renderVaultKeyBtnItems = ({
  dropdown,
  keyBtns,
  targetField,
}: {
  dropdown: HTMLElement;
  keyBtns: HTMLAnchorElement[];
  targetField: HTMLInputElement;
}) => {
  const dropdownContent = dropdown.querySelector('.smyth-dropdown-content');

  dropdownContent.innerHTML = '';

  if (keyBtns?.length) {
    dropdownContent.append(...keyBtns);
  }

  const keyNamesInTheTargetField = getKeyIdsFromTemplateVars(targetField.value);
  const keyNames = keyBtns.map((item) => item.textContent);
  const keyNameToAdd = keyNamesInTheTargetField.find((name) => !keyNames.includes(name));

  // Show the link to add a new key only if:
  // 1. The scope is not global
  const scope = targetField.getAttribute('data-vault') || 'All';
  if (scope !== 'global') {
    const msgElm = _innerLink(targetField, !!keyBtns?.length ? '' : 'No Keys found ', keyNameToAdd);

    dropdownContent.appendChild(msgElm);
  }
};