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.
JavaScript a2aagentic-aiai-agentsdevtoolsmcp-clientn8n-alternativeno-codeopen-sourceorchestrationsmythosvisual-builder
import { Observability } from '@src/shared/observability';
import { lsCache } from '../../../shared/Cache.class';
import { MOCK_DATA_CACHE_KEY } from '../../../shared/constants/general';
import { JSON_FIELD_CLASS } from '../../constants';
import { JsonFieldSynchronizer } from '../../lib/JsonFieldSynchronizer.class';
import { closeTwDialog, twEditValuesWithCallback } from '../../ui/tw-dialogs';
import { parseJson } from '../../utils/data.utils';
import { Workspace } from '../../workspace/Workspace.class';
import { Component } from '../Component.class';
declare var workspace: Workspace;
// #region Mock data storage
// TODO: apply proper clean up strategy when component/agent is removed.
export async function isMockDataEnabled(componentId: string) {
const mockData = await getMockData(componentId);
return mockData?.enabled === true;
}
export async function getMockData(componentId: string) {
const allMockData = lsCache.get(MOCK_DATA_CACHE_KEY) || {};
let data = allMockData?.[componentId];
if (!data) {
try {
const agentId = workspace?.agent?.id;
const res = await fetch(`/api/page/builder/mock-data/${agentId}/${componentId}`);
const resJson = await res.json();
data = resJson?.data;
lsCache.set(MOCK_DATA_CACHE_KEY, { ...allMockData, [componentId]: data });
} catch (error) {
console.warn('Failed to fetch mock data:');
}
}
return data || {};
}
async function insertOrUpdateMockData(componentId: string, mockData: Record<string, any>) {
const _mockData = {
...mockData,
updatedAt: new Date().toISOString(), // We can use updatedAt field to clear old mock data if needed
};
try {
const agentId = workspace?.agent?.id;
const saveMockData = await fetch(`/api/page/builder/mock-data/${agentId}`, {
method: 'PUT',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({ [componentId]: _mockData }),
});
if (saveMockData.ok) {
// Update local storage
const allMockData = lsCache.get(MOCK_DATA_CACHE_KEY) || {};
const existingMockData = allMockData?.[componentId] || {};
const newMockData = { ...existingMockData, ..._mockData };
allMockData[componentId] = newMockData;
lsCache.set(MOCK_DATA_CACHE_KEY, allMockData);
}
} catch {
console.warn('Failed to save Mock Data');
}
}
// #endregion Mock data storage
// #region Mock data configuration dialog
type MockDataButtonState = {
icon: string;
label: string;
color: string;
};
export const MOCK_DATA_BTN_CONFIG: Record<string, string> = {
BUTTON_CLASS: '_mock_data_toggle_btn',
SAVE_BTN_CLASS: '_mock_data_save_btn',
SAVE_BTN_LABEL_CLASS: '_mock_data_save_btn__label',
LABEL_CLASS: '_btn_label',
ICON_CLASS: '_btn_icon',
};
const MOCK_DATA_BTN_STATE: Record<'ENABLED' | 'DISABLED', MockDataButtonState> = {
ENABLED: {
icon: 'fa-toggle-on',
label: 'Mock Data Enabled',
color: 'text-[#3C89F9]',
},
DISABLED: {
icon: 'fa-toggle-off',
label: 'Use Mock Data',
color: 'text-grey-600',
},
};
export function saveMockOutputs(component: Component) {
return new Promise(async (resolve, reject) => {
const createInputList = async (array, type) => {
// #region[mock_data] get mock data
const mockData = await getMockData(component.uid);
const existingOutputs = mockData?.data?.outputs || {};
// #endregion
return array
.map((el, index) => {
// #region[mock_data] get value from mock data
let value: string = existingOutputs?.[el?.name] ?? '';
value = typeof value === 'object' ? JSON.stringify(value, null, 2) : String(value);
// #endregion[mock_data]
const fieldClasses = el?.fieldClasses || '';
const attributes = Object.entries(el?.attributes || {})
.map(([key, value]) => `${key}="${value}"`)
.join(' ');
if (el.type === 'file') {
return `
<div class="flex mb-5">
<span class="inline-flex w-40 items-center px-3 text-sm text-gray-900 bg-gray-200 border border-e-0 border-gray-300 rounded-s-md dark:bg-gray-600 dark:text-gray-400 dark:border-gray-600 break-all">
${el.name}
</span>
<input type="file" name="${el.name}" id="${type}-input-${index}" class="${type}-input input
block w-full text-sm text-slate-500
file:mr-4 file:py-2 file:px-4 file:rounded-md
file:border-0 file:text-sm file:font-semibold
file:bg-gray-200 file:text-gray-900
hover:file:bg-gray-300 pl-5
" multiple>
</div>`;
} else {
return `
<div class="flex mb-5">
<span class="inline-flex w-40 items-center px-3 text-sm text-gray-900 bg-gray-200 border border-e-0 border-gray-300 rounded-s-md dark:bg-gray-600 dark:text-gray-400 dark:border-gray-600 break-all">
${el.name}
</span>
<textarea id="${type}-input-${index}" name="${el.name}" class="${type}-input input block p-1 w-full text-sm text-gray-900 bg-gray-50 rounded-e-md border border-gray-300 focus:ring-blue-500 focus:border-blue-500 ${fieldClasses}" style="min-height:44px; height: 44px;" ${attributes}>${value}</textarea>
</div>`;
}
})
.join('');
};
const outputEndpoints = [...component.domElement.querySelectorAll('.output-endpoint')].map(
(outputEP: HTMLElement) => {
const name = outputEP.getAttribute('smt-name');
const expression = outputEP.getAttribute('smt-expression') || name;
return {
name,
expression,
fieldClasses: JSON_FIELD_CLASS,
attributes: {
'data-expression': expression,
},
};
},
);
const outputsContent = await createInputList(outputEndpoints, 'outputs');
twEditValuesWithCallback({
title: 'Configure Mock Output Data',
content: `
<div class="mb-4">
<p class="text-xs text-gray-500">
Mock output data allows you to test your component without requiring actual API keys or credentials.
Configure sample responses below to simulate the component's behavior.
</p>
</div>
${outputsContent}
`,
actions: [
{
label: `<span class="flex items-center gap-2">
<span class="fa-solid fa-save"></span>
<span class="!text-[#3b82f6] group-hover:!text-white ${MOCK_DATA_BTN_CONFIG.SAVE_BTN_LABEL_CLASS}">Save</span>
</span>`,
cssClass: `border border-[#3b82f6] bg-white hover:bg-[#3b82f6] group transition-all duration-200 !text-[#3b82f6] hover:!text-white ${MOCK_DATA_BTN_CONFIG.SAVE_BTN_CLASS}`,
callback: async (_, dialog) => {
const saveBtn = dialog.querySelector(`.${MOCK_DATA_BTN_CONFIG.SAVE_BTN_CLASS}`);
const btnLabel = saveBtn.querySelector(`.${MOCK_DATA_BTN_CONFIG.SAVE_BTN_LABEL_CLASS}`);
saveBtn.disabled = true;
saveBtn?.classList.add('cursor-not-allowed');
btnLabel.textContent = 'Saving...';
const outputFileValue = {};
const outputs = Array.from(dialog.querySelectorAll('.outputs-input.input')).reduce(
(obj, el: any, index) => {
let val;
try {
if (outputFileValue[index]) {
val = outputFileValue[index].value;
} else {
val = parseJson(el.value) || el.value;
}
} catch (e) {
val = el.value;
}
obj[outputEndpoints[index].name] = val;
return obj;
},
{},
);
try {
await insertOrUpdateMockData(component.uid, { enabled: true, data: { outputs } });
Observability.observeInteraction('app_set_mock_data', {});
resolve('saved');
} finally {
saveBtn.disabled = false;
saveBtn?.classList.remove('cursor-not-allowed');
btnLabel.textContent = 'Save';
closeTwDialog(dialog);
}
},
},
],
onCloseClick: (_, dialog) => {
reject('close'); // Need to reject on close to reset mock data toggle button loading state
closeTwDialog(dialog);
},
onDOMReady: function (dialog) {
const synchronizer = new JsonFieldSynchronizer(dialog.querySelector('.__content'), {
jsonFieldClass: JSON_FIELD_CLASS,
});
// Align actions to the right
const actionsWrapper = dialog.querySelector('.__actions');
actionsWrapper.classList.remove('justify-center');
actionsWrapper.classList.add('justify-end');
},
});
});
}
// #endregion Mock data configuration dialog
// #region UI status management
/**
* Utility for managing debug/mock data Debug Inject output fields
*/
export const DebugInjectOutputFields = {
/**
* Gets all output fields from the dialog and returns them with their attributes
* @param dialog - The HTML dialog element containing output fields
* @returns Array of output fields with their attributes
*/
getOutputFields(dialog: HTMLElement): Array<HTMLTextAreaElement> {
const outputFields = dialog.querySelectorAll(
'.outputs-input.input',
) as NodeListOf<HTMLTextAreaElement>;
return Array.from(outputFields);
},
/**
* Sets mock data values to output fields in the dialog
* @param componentId - ID of the component
* @param dialog - Dialog HTML element
*/
async setMockData(componentId: string, dialog: HTMLElement): Promise<void> {
try {
const mockData = await getMockData(componentId);
const mockedOutputs = mockData?.data?.outputs || {};
this.getOutputFields(dialog).forEach((field) => {
// Set field value from mock data
const fieldName = field.getAttribute('name') || '';
let value: string = mockedOutputs[fieldName] ?? '';
value = typeof value === 'object' ? JSON.stringify(value, null, 2) : String(value);
field.value = value;
});
} catch (error) {
console.error('Failed to set mock data:', error);
}
},
/**
* Applies JSON field synchronizer to output fields
* @param dialog - Dialog HTML element
*/
applyJsonFieldSynchronizer(dialog: HTMLElement): void {
try {
this.getOutputFields(dialog).forEach((field) => {
const name = field.getAttribute('name') || '';
const expression = field.getAttribute('smt-expression') || name;
field.classList.add(JSON_FIELD_CLASS);
field.setAttribute('data-expression', expression);
});
const outputsContainer = dialog.querySelector('#outputs');
if (!outputsContainer) return;
new JsonFieldSynchronizer(outputsContainer, {
jsonFieldClass: JSON_FIELD_CLASS,
});
} catch (error) {
console.error('Failed to apply JSON field synchronizer:');
}
},
};
export async function toggleMockOutputPills(component: Component) {
const outputEndpoints = [...component.domElement.querySelectorAll('.output-endpoint')];
const mockDataEnabled = await isMockDataEnabled(component.uid);
if (mockDataEnabled) {
const mockData = await getMockData(component.uid);
for (const endpoint of outputEndpoints) {
const name = endpoint.getAttribute('smt-name');
let value = mockData?.data?.outputs?.[name];
if (value) {
endpoint.setAttribute(
'smt-mock-data',
typeof value === 'object' ? JSON.stringify(value) : value,
);
}
}
} else {
outputEndpoints.forEach((ep) => {
ep.removeAttribute('smt-mock-data');
});
}
}
export const MockDataToggleButtonState = {
elements(component: Component) {
return {
button: component.domElement.querySelector(`.${MOCK_DATA_BTN_CONFIG.BUTTON_CLASS}`),
label: component.domElement.querySelector(`.${MOCK_DATA_BTN_CONFIG.LABEL_CLASS}`),
icon: component.domElement.querySelector(`.${MOCK_DATA_BTN_CONFIG.ICON_CLASS}`),
};
},
turnOn(component: Component) {
const { button, label, icon } = this.elements(component);
button.classList.remove(MOCK_DATA_BTN_STATE.DISABLED.color);
button.classList.add(MOCK_DATA_BTN_STATE.ENABLED.color);
label.textContent = MOCK_DATA_BTN_STATE.ENABLED.label;
icon.classList.remove(MOCK_DATA_BTN_STATE.DISABLED.icon);
icon.classList.add(MOCK_DATA_BTN_STATE.ENABLED.icon);
},
turnOff(component: Component) {
const { button, label, icon } = this.elements(component);
button.classList.remove(MOCK_DATA_BTN_STATE.ENABLED.color);
button.classList.add(MOCK_DATA_BTN_STATE.DISABLED.color);
label.textContent = MOCK_DATA_BTN_STATE.DISABLED.label;
icon.classList.remove(MOCK_DATA_BTN_STATE.ENABLED.icon);
icon.classList.add(MOCK_DATA_BTN_STATE.DISABLED.icon);
},
/**
* Enters loading state for the toggle button
* @param component - Target component instance
*/
setLoadingState(component: Component) {
const { button } = this.elements(component);
if (button.classList.contains('text-[#3C89F9]')) {
button.classList.remove('text-[#3C89F9]');
}
button.disabled = true;
button.classList.add('cursor-not-allowed');
},
/**
* Exits loading state for the toggle button
* @param component - Target component instance
*/
clearLoadingState(component: Component) {
const { button } = this.elements(component);
button.disabled = false;
button.classList.remove('cursor-not-allowed');
},
};
const pendingButtonOps = new Set<string>();
export async function addMockDataToggleButton(component: Component) {
const componentId = component.uid;
/**
* Prevents concurrent executions of addMockDataToggleButton for the same component.
*
* This protection mechanism is necessary because the parent checkSettings function
* is often called without awaiting its promise, which means addMockDataToggleButton
* could be invoked multiple times for the same component, leading to:
* 1. Race conditions in UI updates (e.g., duplicate toggle buttons)
* 2. Inconsistent component state
*
* The pattern works by:
* - Adding the component's UID to the pendingButtonOps Set at the start
* - Returning early if the UID is already in the Set
* - Removing the UID from the Set once processing completes (or if an error occurs)
*/
if (pendingButtonOps.has(componentId)) return;
pendingButtonOps.add(componentId);
try {
const mockDataEnabled = await isMockDataEnabled(componentId);
const mockDataState = mockDataEnabled ? 'ENABLED' : 'DISABLED';
let btnLabel = MOCK_DATA_BTN_STATE[mockDataState].label;
let btnIcon = MOCK_DATA_BTN_STATE[mockDataState].icon;
let btnColor = MOCK_DATA_BTN_STATE[mockDataState].color;
component.addComponentButton(
`<div class="fa-solid ${btnIcon} text-base _btn_icon"></div>
<span class="ml-2 font-semibold _btn_label">${btnLabel}</span>`,
' ',
{
class: `${MOCK_DATA_BTN_CONFIG.BUTTON_CLASS} ${btnColor} transition-opacity duration-300`,
customStyle: 'toggle',
position: 'top',
},
async () => {
try {
const toggleMockData = async () => {
const mockDataEnabled = await isMockDataEnabled(componentId);
if (mockDataEnabled) {
await insertOrUpdateMockData(component.uid, { enabled: false });
MockDataToggleButtonState.turnOff(component);
} else {
Observability.observeInteraction('app_mock_screen_impression', {
source: 'use_mock_data_button',
});
await saveMockOutputs(component);
MockDataToggleButtonState.turnOn(component);
}
};
MockDataToggleButtonState.setLoadingState(component);
await toggleMockData();
await toggleMockOutputPills(component);
} catch (error) {
console.error('Failed to toggle mock data');
} finally {
MockDataToggleButtonState.clearLoadingState(component);
}
},
);
} finally {
// Always remove from pending set when done, regardless of success or failure
pendingButtonOps.delete(componentId);
}
}
// #endregion UI status management