@promptbook/cli 0.113.0-1 → 0.113.0-11

package/apps/agents-server/src/app/layout.tsx

@@ -23,6 +23,7 @@ import type { AgentOrganizationAgent, AgentOrganizationFolder } from '../utils/a
 import { getAgentNaming } from '../utils/getAgentNaming';
 import { getCurrentUser } from '../utils/getCurrentUser';
 import { getDefaultChatPreferences } from '../utils/chatPreferences';
+import { formatServerLanguageHumanReadableDate } from '../utils/localization/formatServerLanguageHumanReadableDate';
 import {
     CHAT_VISUAL_MODE_COOKIE_NAME,
     CHAT_VISUAL_MODE_METADATA_KEY,
@@ -32,11 +33,7 @@ import {
     DEFAULT_AGENT_AVATAR_VISUAL_METADATA_KEY,
     resolveDefaultAgentAvatarVisualId,
 } from '../constants/defaultAgentAvatarVisual';
-import {
-    DEFAULT_THEME_METADATA_KEY,
-    THEME_MODE_COOKIE_NAME,
-    resolveThemeMode,
-} from '../constants/themeMode';
+import { DEFAULT_THEME_METADATA_KEY, THEME_MODE_COOKIE_NAME, resolveThemeMode } from '../constants/themeMode';
 import { parseChatFeedbackMode } from '../utils/chatFeedbackMode';
 import { getFederatedServers } from '../utils/getFederatedServers';
 import { isUserAdmin } from '../utils/isUserAdmin';
@@ -53,6 +50,9 @@ import {
     resolveShibbolethAuthenticationMenuStatus,
 } from '../constants/shibbolethAuth';
 import { resolveFileUploadAvailability } from '../utils/upload/fileUploadAvailability';
+import { readServerResourceWarningStatus } from '../utils/resourceMonitor/readServerResourceMonitorSnapshot';
+import { RESOURCE_MONITOR_OK_WARNING_STATUS } from '../utils/resourceMonitor/resourceMonitorTypes';
+import { readAgentsServerFooterVersion } from '../utils/vpsSelfUpdate/readAgentsServerFooterVersion';
 import '@prisma/studio-core/ui/index.css';
 import './globals.css';
 
@@ -270,6 +270,18 @@ export default async function RootLayout({
     const currentUserPromise = getCurrentUser();
     const isAdminPromise = isUserAdmin();
     const isGlobalAdminPromise = isUserGlobalAdmin();
+    const resourceMonitorWarningStatusPromise = isGlobalAdminPromise.then(async (isGlobalAdmin) => {
+        if (!isGlobalAdmin) {
+            return RESOURCE_MONITOR_OK_WARNING_STATUS;
+        }
+
+        try {
+            return await readServerResourceWarningStatus();
+        } catch (error) {
+            console.error('Failed to resolve resource monitor warning status:', error);
+            return RESOURCE_MONITOR_OK_WARNING_STATUS;
+        }
+    });
     const providedServerPromise = $provideServer();
     const serverVisibilityPromise = getServerVisibility();
     const agentNamingPromise = getAgentNaming();
@@ -278,6 +290,7 @@ export default async function RootLayout({
     );
     const chatPreferencesPromise = getDefaultChatPreferences();
     const defaultIsNotificationsOnPromise = getDefaultIsNotificationsOn();
+    const footerVersionMetadataPromise = readAgentsServerFooterVersion();
     const fileUploadAvailabilityPromise = providedServerPromise.then((providedServer) =>
         resolveFileUploadAvailability({
             serverId: providedServer.id,
@@ -289,10 +302,7 @@ export default async function RootLayout({
         'custom stylesheet CSS',
         getAggregatedCustomStylesheetCss,
     );
-    const customJavascriptPromise = resolveOptionalLayoutText(
-        'custom JavaScript',
-        getCustomJavascriptWithIntegrations,
-    );
+    const customJavascriptPromise = resolveOptionalLayoutText('custom JavaScript', getCustomJavascriptWithIntegrations);
     const cookieStorePromise = cookies();
     const requestHeadersPromise = headers();
     const defaultThemeModePromise = Promise.all([currentUserPromise, cookieStorePromise, layoutMetadataPromise]).then(
@@ -318,23 +328,25 @@ export default async function RootLayout({
                 showFederatedServersPublicly: (layoutMetadata.SHOW_FEDERATED_SERVERS_PUBLICLY ?? 'false') === 'true',
             }),
     );
-    const footerLinksPromise = Promise.all([layoutMetadataPromise, federatedServersPromise, serverVisibilityPromise]).then(
-        ([layoutMetadata, federatedServers, serverVisibility]) => {
-            const footerLinks = [
-                ...parseFooterLinks(layoutMetadata.FOOTER_LINKS),
-                ...federatedServers.map(({ title, url }) => ({ title, url })),
-            ];
+    const footerLinksPromise = Promise.all([
+        layoutMetadataPromise,
+        federatedServersPromise,
+        serverVisibilityPromise,
+    ]).then(([layoutMetadata, federatedServers, serverVisibility]) => {
+        const footerLinks = [
+            ...parseFooterLinks(layoutMetadata.FOOTER_LINKS),
+            ...federatedServers.map(({ title, url }) => ({ title, url })),
+        ];
 
-            if (isPublicServerVisibility(serverVisibility)) {
-                footerLinks.push({
-                    title: 'Sitemap',
-                    url: '/sitemap.xml',
-                });
-            }
+        if (isPublicServerVisibility(serverVisibility)) {
+            footerLinks.push({
+                title: 'Sitemap',
+                url: '/sitemap.xml',
+            });
+        }
 
-            return footerLinks;
-        },
-    );
+        return footerLinks;
+    });
 
     const [
         isAdmin,
@@ -354,6 +366,8 @@ export default async function RootLayout({
         footerLinks,
         serverVisibility,
         fileUploadAvailability,
+        resourceMonitorWarningStatus,
+        footerVersionMetadata,
     ] = await Promise.all([
         isAdminPromise,
         isGlobalAdminPromise,
@@ -372,6 +386,8 @@ export default async function RootLayout({
         footerLinksPromise,
         serverVisibilityPromise,
         fileUploadAvailabilityPromise,
+        resourceMonitorWarningStatusPromise,
+        footerVersionMetadataPromise,
     ]);
 
     const serverName = layoutMetadata.SERVER_NAME || 'Promptbook Agents Server';
@@ -400,6 +416,16 @@ export default async function RootLayout({
     const defaultAgentAvatarVisualId = resolveDefaultAgentAvatarVisualId(rawDefaultAgentAvatarVisual);
     const preferredLanguageSource = isServerLanguageEnforced ? rawServerLanguage : cookieLanguage || rawServerLanguage;
     const serverLanguage = resolveServerLanguageCode(preferredLanguageSource);
+    const footerVersionReleasedAtLabel =
+        formatServerLanguageHumanReadableDate(footerVersionMetadata.releasedAt, serverLanguage, {
+            fallbackLabel: '',
+        }) || null;
+    const footerVersion = {
+        label: footerVersionMetadata.label,
+        url: footerVersionMetadata.versionUrl,
+        commitSha: footerVersionMetadata.currentCommitSha,
+        releasedAtLabel: footerVersionReleasedAtLabel,
+    };
     const controlPanelOptionAvailability = getControlPanelOptionAvailability({
         metadata: layoutMetadata,
         isPushNotificationsConfigured: Boolean(webPushPublicKey),
@@ -433,7 +459,10 @@ export default async function RootLayout({
                     agentFolders={JSON.parse(JSON.stringify(agentFolders))}
                     agentNaming={agentNaming}
                     isFooterShown={isFooterShown}
-                    footerLinks={isPublicServer ? footerLinks : footerLinks.filter((link) => link.url !== '/sitemap.xml')}
+                    footerLinks={
+                        isPublicServer ? footerLinks : footerLinks.filter((link) => link.url !== '/sitemap.xml')
+                    }
+                    footerVersion={footerVersion}
                     federatedServers={federatedServers}
                     defaultIsSoundsOn={chatPreferences.defaultIsSoundsOn}
                     defaultIsVibrationOn={chatPreferences.defaultIsVibrationOn}
@@ -441,6 +470,7 @@ export default async function RootLayout({
                     isExperimental={isExperimental}
                     feedbackMode={feedbackMode}
                     shibbolethAuthenticationStatus={shibbolethAuthenticationStatus}
+                    resourceMonitorWarningStatus={resourceMonitorWarningStatus}
                     isExperimentalPwaAppEnabled={isExperimentalPwaAppEnabled}
                     controlPanelOptionAvailability={controlPanelOptionAvailability}
                     defaultServerLanguage={serverLanguage}

package/apps/agents-server/src/app/system/utilities/mocked-chats/cloneMockedChatPreset.ts

@@ -0,0 +1,17 @@
+import type { MockedChatPreset } from '@/src/utils/mockedChatsSchema';
+
+/**
+ * Clones one mocked-chat preset so editor state does not mutate saved references.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function cloneMockedChatPreset(preset: MockedChatPreset): MockedChatPreset {
+    return {
+        ...preset,
+        participants: preset.participants.map((participant) => ({ ...participant })),
+        messages: preset.messages.map((message) => ({ ...message })),
+        settings: {
+            ...preset.settings,
+        },
+    };
+}

package/apps/agents-server/src/app/system/utilities/mocked-chats/confirmDeleteMockedChat.ts

@@ -0,0 +1,16 @@
+import { showConfirm } from '@/src/components/AsyncDialogs/asyncDialogs';
+import type { MockedChatPreset } from '@/src/utils/mockedChatsSchema';
+
+/**
+ * Requests confirmation before deleting one mocked chat.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export async function confirmDeleteMockedChat(targetChat: MockedChatPreset): Promise<boolean> {
+    return showConfirm({
+        title: 'Delete mocked chat',
+        message: `Delete "${targetChat.name}"? This cannot be undone.`,
+        confirmLabel: 'Delete mocked chat',
+        cancelLabel: 'Cancel',
+    }).catch(() => false);
+}

package/apps/agents-server/src/app/system/utilities/mocked-chats/createDraftWithUpdatedMessage.ts

@@ -0,0 +1,81 @@
+import {
+    createMockedChatMessageId,
+    type MockedChatParticipant,
+    type MockedChatPreset,
+    type MockedChatScriptedMessage,
+} from '@/src/utils/mockedChatsSchema';
+
+/**
+ * Fallback offset distance when adding new scripted messages.
+ *
+ * @private constant of <MockedChatsEditorClient/>
+ */
+const DEFAULT_NEW_MESSAGE_OFFSET_STEP_MS = 1_200;
+
+/**
+ * Adds one scripted message at the end of the sequence.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftWithAddedMessage(previousDraft: MockedChatPreset): MockedChatPreset {
+    const previousOffset = previousDraft.messages[previousDraft.messages.length - 1]?.offsetMs || 0;
+
+    const nextMessage: MockedChatScriptedMessage = {
+        id: createMockedChatMessageId(),
+        senderId: resolveDefaultMessageSenderId(previousDraft.participants),
+        content: 'New scripted message',
+        offsetMs: previousOffset + DEFAULT_NEW_MESSAGE_OFFSET_STEP_MS,
+    };
+
+    return {
+        ...previousDraft,
+        messages: [...previousDraft.messages, nextMessage],
+    };
+}
+
+/**
+ * Updates one scripted message field.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftWithUpdatedMessage<TField extends keyof MockedChatScriptedMessage>(
+    previousDraft: MockedChatPreset,
+    messageId: string,
+    field: TField,
+    value: MockedChatScriptedMessage[TField],
+): MockedChatPreset {
+    return {
+        ...previousDraft,
+        messages: previousDraft.messages.map((message) => {
+            if (message.id !== messageId) {
+                return message;
+            }
+
+            return {
+                ...message,
+                [field]: value,
+            };
+        }),
+    };
+}
+
+/**
+ * Removes one scripted message.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftWithRemovedMessage(previousDraft: MockedChatPreset, messageId: string): MockedChatPreset {
+    return {
+        ...previousDraft,
+        messages: previousDraft.messages.filter((message) => message.id !== messageId),
+    };
+}
+
+/**
+ * Resolves the participant used for newly added scripted messages.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+function resolveDefaultMessageSenderId(participants: ReadonlyArray<MockedChatParticipant>): string {
+    return participants.find((participant) => participant.isMe)?.id || participants[0]?.id || 'USER';
+}

package/apps/agents-server/src/app/system/utilities/mocked-chats/createDraftWithUpdatedParticipant.ts

@@ -0,0 +1,146 @@
+import {
+    createMockedChatParticipantId,
+    type MockedChatParticipant,
+    type MockedChatPreset,
+    type MockedChatScriptedMessage,
+} from '@/src/utils/mockedChatsSchema';
+
+/**
+ * Adds one participant to the current draft.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftWithAddedParticipant(previousDraft: MockedChatPreset): MockedChatPreset {
+    const nextParticipants = [...previousDraft.participants, createDraftParticipant(previousDraft.participants.length)];
+
+    return {
+        ...previousDraft,
+        participants: nextParticipants,
+    };
+}
+
+/**
+ * Updates one participant field in the draft.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftWithUpdatedParticipant<TField extends keyof MockedChatParticipant>(
+    previousDraft: MockedChatPreset,
+    participantId: string,
+    field: TField,
+    value: MockedChatParticipant[TField],
+): MockedChatPreset {
+    const nextParticipants = updateParticipantsAfterFieldChange(previousDraft.participants, participantId, field, value);
+    const fallbackSenderId = nextParticipants[0]?.id || previousDraft.messages[0]?.senderId || 'USER';
+
+    return {
+        ...previousDraft,
+        participants: nextParticipants,
+        messages: reconcileMessageSenderIds(previousDraft.messages, nextParticipants, fallbackSenderId),
+    };
+}
+
+/**
+ * Removes one participant from the draft.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftWithRemovedParticipant(previousDraft: MockedChatPreset, participantId: string): MockedChatPreset {
+    const remainingParticipants = previousDraft.participants.filter((participant) => participant.id !== participantId);
+    if (remainingParticipants.length === 0) {
+        return previousDraft;
+    }
+
+    const nextParticipants = ensureParticipantMarkedAsMe(remainingParticipants);
+    const fallbackSenderId = nextParticipants[0]?.id || 'USER';
+
+    return {
+        ...previousDraft,
+        participants: nextParticipants,
+        messages: reconcileMessageSenderIds(previousDraft.messages, nextParticipants, fallbackSenderId),
+    };
+}
+
+/**
+ * Creates one participant draft with deterministic defaults.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+function createDraftParticipant(participantCount: number): MockedChatParticipant {
+    return {
+        id: createMockedChatParticipantId(),
+        name: `Participant ${participantCount + 1}`,
+        isMe: participantCount === 0,
+        bubbleColor: '#2563eb',
+        avatarUrl: null,
+        typingAvatarUrl: null,
+    };
+}
+
+/**
+ * Ensures at least one participant remains marked as `isMe`.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+function ensureParticipantMarkedAsMe(participants: Array<MockedChatParticipant>): Array<MockedChatParticipant> {
+    if (participants.some((participant) => participant.isMe) || participants.length === 0) {
+        return participants;
+    }
+
+    const nextParticipants = [...participants];
+    nextParticipants[0] = {
+        ...nextParticipants[0],
+        isMe: true,
+    };
+    return nextParticipants;
+}
+
+/**
+ * Reconciles message sender ids after participant changes.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+function reconcileMessageSenderIds(
+    messages: ReadonlyArray<MockedChatScriptedMessage>,
+    participants: ReadonlyArray<MockedChatParticipant>,
+    fallbackSenderId: string,
+): Array<MockedChatScriptedMessage> {
+    return messages.map((message) => ({
+        ...message,
+        senderId: participants.some((participant) => participant.id === message.senderId)
+            ? message.senderId
+            : fallbackSenderId,
+    }));
+}
+
+/**
+ * Applies one participant field update and keeps the "me" invariant.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+function updateParticipantsAfterFieldChange<TField extends keyof MockedChatParticipant>(
+    participants: ReadonlyArray<MockedChatParticipant>,
+    participantId: string,
+    field: TField,
+    value: MockedChatParticipant[TField],
+): Array<MockedChatParticipant> {
+    let nextParticipants = participants.map((participant) => {
+        if (participant.id !== participantId) {
+            return participant;
+        }
+
+        return {
+            ...participant,
+            [field]: value,
+        };
+    });
+
+    if (field === 'isMe' && value === true) {
+        nextParticipants = nextParticipants.map((participant) => ({
+            ...participant,
+            isMe: participant.id === participantId,
+        }));
+    }
+
+    return nextParticipants;
+}

package/apps/agents-server/src/app/system/utilities/mocked-chats/createDraftWithUpdatedSettings.ts

@@ -0,0 +1,19 @@
+import type { MockedChatPreset, MockedChatSettings } from '@/src/utils/mockedChatsSchema';
+
+/**
+ * Applies one settings patch to the draft.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftWithUpdatedSettings(
+    previousDraft: MockedChatPreset,
+    settingsPatch: Partial<MockedChatSettings>,
+): MockedChatPreset {
+    return {
+        ...previousDraft,
+        settings: {
+            ...previousDraft.settings,
+            ...settingsPatch,
+        },
+    };
+}

package/apps/agents-server/src/app/system/utilities/mocked-chats/createDuplicatedDraft.ts

@@ -0,0 +1,66 @@
+import { createMockedChatId, type MockedChatPreset } from '@/src/utils/mockedChatsSchema';
+import { cloneMockedChatPreset } from './cloneMockedChatPreset';
+
+/**
+ * Creates a local duplicate draft from the current editor content.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDuplicatedDraft(draftChat: MockedChatPreset): MockedChatPreset {
+    const duplicatedDraft = cloneMockedChatPreset(draftChat);
+    duplicatedDraft.id = createMockedChatId();
+    duplicatedDraft.name = buildCopyName(draftChat.name);
+    duplicatedDraft.createdAt = new Date().toISOString();
+    duplicatedDraft.updatedAt = duplicatedDraft.createdAt;
+    return duplicatedDraft;
+}
+
+/**
+ * Normalizes the draft before saving it over its current id.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createNormalizedDraftForSave(
+    draftChat: MockedChatPreset,
+    selectedSavedChat: MockedChatPreset | null,
+): MockedChatPreset {
+    const nowIso = new Date().toISOString();
+
+    return {
+        ...cloneMockedChatPreset(draftChat),
+        name: draftChat.name.trim() || 'Untitled mocked chat',
+        updatedAt: nowIso,
+        createdAt: selectedSavedChat?.createdAt || draftChat.createdAt || nowIso,
+    };
+}
+
+/**
+ * Creates the saved-copy payload used by "Save as New".
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftForSaveAsNew(draftChat: MockedChatPreset): MockedChatPreset {
+    const nowIso = new Date().toISOString();
+
+    return {
+        ...cloneMockedChatPreset(draftChat),
+        id: createMockedChatId(),
+        name: buildCopyName(draftChat.name),
+        createdAt: nowIso,
+        updatedAt: nowIso,
+    };
+}
+
+/**
+ * Builds a user-friendly duplicate name.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+function buildCopyName(name: string): string {
+    const trimmedName = name.trim();
+    if (!trimmedName) {
+        return 'Untitled mocked chat copy';
+    }
+
+    return trimmedName.toLowerCase().endsWith('copy') ? trimmedName : `${trimmedName} copy`;
+}

package/apps/agents-server/src/app/system/utilities/mocked-chats/findMockedChatById.ts

@@ -0,0 +1,51 @@
+import type { MockedChatPreset } from '@/src/utils/mockedChatsSchema';
+
+/**
+ * Finds one mocked chat by id.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function findMockedChatById(
+    mockedChats: ReadonlyArray<MockedChatPreset>,
+    mockedChatId: string | null,
+): MockedChatPreset | null {
+    if (!mockedChatId) {
+        return null;
+    }
+
+    return mockedChats.find((mockedChat) => mockedChat.id === mockedChatId) || null;
+}
+
+/**
+ * Checks whether the draft differs from the selected saved chat.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function isMockedChatDraftDirty(selectedSavedChat: MockedChatPreset | null, draftChat: MockedChatPreset): boolean {
+    if (!selectedSavedChat) {
+        return true;
+    }
+
+    return JSON.stringify(selectedSavedChat) !== JSON.stringify(draftChat);
+}
+
+/**
+ * Upserts one mocked-chat preset by id while preserving list order by updated date.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function upsertMockedChatPreset(
+    presets: ReadonlyArray<MockedChatPreset>,
+    incomingPreset: MockedChatPreset,
+): Array<MockedChatPreset> {
+    const existingIndex = presets.findIndex((preset) => preset.id === incomingPreset.id);
+    const nextPresets = [...presets];
+
+    if (existingIndex === -1) {
+        nextPresets.push(incomingPreset);
+    } else {
+        nextPresets[existingIndex] = incomingPreset;
+    }
+
+    return nextPresets.sort((leftPreset, rightPreset) => Date.parse(rightPreset.updatedAt) - Date.parse(leftPreset.updatedAt));
+}

package/apps/agents-server/src/app/system/utilities/mocked-chats/persistMockedChats.ts

@@ -0,0 +1,51 @@
+import type { MockedChatPreset } from '@/src/utils/mockedChatsSchema';
+
+/**
+ * API endpoint used by the mocked-chat editor.
+ *
+ * @private constant of <MockedChatsEditorClient/>
+ */
+const MOCKED_CHATS_API_ENDPOINT = '/api/system/mocked-chats';
+
+/**
+ * API payload returned by mocked-chat routes.
+ *
+ * @private type of <MockedChatsEditorClient/>
+ */
+type MockedChatsApiPayload = {
+    mockedChats: Array<MockedChatPreset>;
+};
+
+/**
+ * Persists one full mocked-chat list and returns server-normalized records.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export async function persistMockedChats(nextMockedChats: Array<MockedChatPreset>): Promise<Array<MockedChatPreset>> {
+    const response = await fetch(MOCKED_CHATS_API_ENDPOINT, {
+        method: 'PUT',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ mockedChats: nextMockedChats }),
+    });
+
+    const payload = (await response.json().catch(() => ({}))) as Partial<MockedChatsApiPayload> & {
+        error?: string;
+    };
+
+    if (!response.ok || !Array.isArray(payload.mockedChats)) {
+        throw new Error(payload.error || 'Failed to save mocked chats.');
+    }
+
+    return payload.mockedChats;
+}
+
+/**
+ * Resolves the user-facing error message for one mocked-chat action.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function resolveMockedChatsActionErrorMessage(error: unknown, fallbackMessage: string): string {
+    return error instanceof Error ? error.message : fallbackMessage;
+}