@promptbook/cli 0.113.0-4 → 0.113.0-8

package/apps/agents-server/src/utils/backup/serverBackup/appendAgentBackupEntriesToZip.ts

@@ -0,0 +1,27 @@
+import JSZip from 'jszip';
+import type { ServerBackupSectionDefinition } from '../serverBackupSections';
+import { loadBackupTableFilePayload, type ServerBackupContext } from './serverBackupContext';
+
+/**
+ * Writes the legacy table-backed agent export while keeping the books tree unchanged.
+ *
+ * @param zip - ZIP archive being assembled.
+ * @param sectionRootPath - Root path for the agents section.
+ * @param sectionDefinition - Agents section definition.
+ * @param context - Shared backup context.
+ *
+ * @private function of `createServerBackupZipStream`
+ */
+export async function appendAgentBackupEntriesToZip(
+    zip: JSZip,
+    sectionRootPath: string,
+    sectionDefinition: ServerBackupSectionDefinition,
+    context: ServerBackupContext,
+): Promise<void> {
+    const tableKeys = sectionDefinition.tables || [];
+
+    for (const tableKey of tableKeys) {
+        const tablePayload = await loadBackupTableFilePayload(context.supabase, tableKey);
+        zip.file(`${sectionRootPath}/${tableKey}.json`, `${JSON.stringify(tablePayload, null, 2)}\n`);
+    }
+}

package/apps/agents-server/src/utils/backup/serverBackup/appendConversationBackupEntriesToZip.ts

@@ -0,0 +1,140 @@
+import JSZip from 'jszip';
+import { resolveFeedbackThreadMessages } from './resolveFeedbackThreadMessages';
+import {
+    loadAgentRows,
+    loadChatFeedbackRows,
+    loadUserChatRows,
+    loadUserRows,
+    type ServerBackupContext,
+} from './serverBackupContext';
+import {
+    createBackupStem,
+    createJsonMetadataFilename,
+    createUniqueBackupFilename,
+    ensureJsonFilename,
+} from './serverBackupFilenames';
+import { createAgentPreviewByName, createAgentPreviewByPermanentId, createUserPreviewById } from './serverBackupPreviews';
+import { normalizeOptionalText, resolveSerializableArray } from './serverBackupRowUtilities';
+
+/**
+ * Writes one JSON chat export per conversation and per feedback thread.
+ *
+ * @param zip - ZIP archive being assembled.
+ * @param sectionRootPath - Root path for the conversations section.
+ * @param context - Shared backup context.
+ *
+ * @private function of `createServerBackupZipStream`
+ */
+export async function appendConversationBackupEntriesToZip(
+    zip: JSZip,
+    sectionRootPath: string,
+    context: ServerBackupContext,
+): Promise<void> {
+    const [userChats, users, agents, feedbackRows] = await Promise.all([
+        loadUserChatRows(context),
+        loadUserRows(context),
+        loadAgentRows(context),
+        loadChatFeedbackRows(context),
+    ]);
+
+    const chatsRootPath = `${sectionRootPath}/chats`;
+    const feedbackRootPath = `${sectionRootPath}/feedback`;
+    const usedChatFilenames = new Set<string>();
+    const usedFeedbackFilenames = new Set<string>();
+    const userPreviewById = createUserPreviewById(users);
+    const agentPreviewByPermanentId = createAgentPreviewByPermanentId(agents);
+    const agentPreviewByName = createAgentPreviewByName(agents);
+
+    zip.folder(chatsRootPath);
+    zip.folder(feedbackRootPath);
+
+    for (const chat of userChats) {
+        const userPreview = userPreviewById.get(chat.userId) || null;
+        const agentPreview = agentPreviewByPermanentId.get(chat.agentPermanentId) || {
+            id: 0,
+            agentName: chat.agentPermanentId,
+            permanentId: chat.agentPermanentId,
+        };
+        const chatMessages = resolveSerializableArray(chat.messages);
+        const preferredFilename = ensureJsonFilename(
+            createBackupStem(
+                [userPreview?.username, agentPreview.agentName, normalizeOptionalText(chat.title), 'conversation'],
+                `chat-${chat.id}`,
+            ),
+        );
+        const filename = createUniqueBackupFilename(
+            usedChatFilenames,
+            preferredFilename,
+            `chat-${chat.id}`,
+        );
+        const metadataFilename = createJsonMetadataFilename(filename);
+
+        zip.file(`${chatsRootPath}/${filename}`, `${JSON.stringify(chatMessages, null, 2)}\n`);
+        zip.file(
+            `${chatsRootPath}/${metadataFilename}`,
+            `${JSON.stringify(
+                {
+                    kind: 'user-chat',
+                    chatId: chat.id,
+                    title: chat.title,
+                    createdAt: chat.createdAt,
+                    updatedAt: chat.updatedAt,
+                    lastMessageAt: chat.lastMessageAt,
+                    source: chat.source,
+                    draftMessage: chat.draftMessage,
+                    messageCount: chatMessages.length,
+                    user: userPreview,
+                    agent: agentPreview,
+                },
+                null,
+                2,
+            )}\n`,
+        );
+    }
+
+    for (const feedback of feedbackRows) {
+        const { messages, rawChatThreadText } = resolveFeedbackThreadMessages(feedback.chatThread);
+        const agentPreview = agentPreviewByName.get(feedback.agentName) || {
+            id: 0,
+            agentName: feedback.agentName,
+            permanentId: null,
+        };
+        const preferredFilename = ensureJsonFilename(
+            createBackupStem(
+                [feedback.agentName, normalizeOptionalText(feedback.textRating), `feedback ${feedback.id}`],
+                `feedback-${feedback.id}`,
+            ),
+        );
+        const filename = createUniqueBackupFilename(
+            usedFeedbackFilenames,
+            preferredFilename,
+            `feedback-${feedback.id}`,
+        );
+        const metadataFilename = createJsonMetadataFilename(filename);
+
+        zip.file(`${feedbackRootPath}/${filename}`, `${JSON.stringify(messages, null, 2)}\n`);
+        zip.file(
+            `${feedbackRootPath}/${metadataFilename}`,
+            `${JSON.stringify(
+                {
+                    kind: 'chat-feedback',
+                    feedbackId: feedback.id,
+                    createdAt: feedback.createdAt,
+                    agent: agentPreview,
+                    rating: feedback.rating,
+                    textRating: feedback.textRating,
+                    userNote: feedback.userNote,
+                    expectedAnswer: feedback.expectedAnswer,
+                    promptbookEngineVersion: feedback.promptbookEngineVersion,
+                    url: feedback.url,
+                    language: feedback.language,
+                    platform: feedback.platform,
+                    messageCount: messages.length,
+                    ...(rawChatThreadText ? { rawChatThreadText } : {}),
+                },
+                null,
+                2,
+            )}\n`,
+        );
+    }
+}

package/apps/agents-server/src/utils/backup/serverBackup/appendFileBackupEntriesToZip.ts

@@ -0,0 +1,147 @@
+import JSZip from 'jszip';
+import { downloadBackupBinaryContent } from './downloadBackupBinaryContent';
+import {
+    createAttachmentReferencesByUrl,
+    resolveAttachmentReferencesForUrls,
+} from './serverBackupAttachments';
+import {
+    loadAgentRows,
+    loadChatFeedbackRows,
+    loadTableRows,
+    loadUserChatRows,
+    loadUserRows,
+    type ServerBackupContext,
+} from './serverBackupContext';
+import {
+    createBinaryMetadataFilename,
+    createUniqueBackupFilename,
+    resolveBinaryBackupFilename,
+    resolvePathBasename,
+} from './serverBackupFilenames';
+import {
+    createAgentPreviewById,
+    createAgentPreviewByName,
+    createAgentPreviewByPermanentId,
+    createUserPreviewById,
+} from './serverBackupPreviews';
+import { deduplicateSerializableObjects, normalizeOptionalText } from './serverBackupRowUtilities';
+
+/**
+ * Writes uploaded files and generated images together with sidecar restore metadata.
+ *
+ * @param zip - ZIP archive being assembled.
+ * @param sectionRootPath - Root path for the files section.
+ * @param context - Shared backup context.
+ *
+ * @private function of `createServerBackupZipStream`
+ */
+export async function appendFileBackupEntriesToZip(
+    zip: JSZip,
+    sectionRootPath: string,
+    context: ServerBackupContext,
+): Promise<void> {
+    const [fileRows, imageRows, users, agents, userChats, feedbackRows] = await Promise.all([
+        loadTableRows(context.supabase, 'File'),
+        loadTableRows(context.supabase, 'Image'),
+        loadUserRows(context),
+        loadAgentRows(context),
+        loadUserChatRows(context),
+        loadChatFeedbackRows(context),
+    ]);
+    const uploadsRootPath = `${sectionRootPath}/uploads`;
+    const imagesRootPath = `${sectionRootPath}/images`;
+    const usedUploadFilenames = new Set<string>();
+    const usedImageFilenames = new Set<string>();
+    const userPreviewById = createUserPreviewById(users);
+    const agentPreviewById = createAgentPreviewById(agents);
+    const agentPreviewByPermanentId = createAgentPreviewByPermanentId(agents);
+    const agentPreviewByName = createAgentPreviewByName(agents);
+    const attachmentReferencesByUrl = createAttachmentReferencesByUrl({
+        userChats,
+        feedbackRows,
+        userPreviewById,
+        agentPreviewByPermanentId,
+        agentPreviewByName,
+    });
+
+    zip.folder(uploadsRootPath);
+    zip.folder(imagesRootPath);
+
+    for (const fileRow of fileRows) {
+        const contentUrl = normalizeOptionalText(fileRow.storageUrl) || normalizeOptionalText(fileRow.shortUrl);
+        const filename = createUniqueBackupFilename(
+            usedUploadFilenames,
+            resolveBinaryBackupFilename(fileRow.fileName, contentUrl, `file-${fileRow.id}`),
+            `file-${fileRow.id}`,
+        );
+        const downloadResult = await downloadBackupBinaryContent(contentUrl);
+        const attachedToMessages = deduplicateSerializableObjects(
+            resolveAttachmentReferencesForUrls(
+                attachmentReferencesByUrl,
+                [fileRow.storageUrl, fileRow.shortUrl],
+            ),
+        );
+
+        if (downloadResult.content) {
+            zip.file(`${uploadsRootPath}/${filename}`, downloadResult.content);
+        }
+
+        zip.file(
+            `${uploadsRootPath}/${createBinaryMetadataFilename(filename)}`,
+            `${JSON.stringify(
+                {
+                    kind: 'uploaded-file',
+                    id: fileRow.id,
+                    createdAt: fileRow.createdAt,
+                    originalFileName: resolvePathBasename(fileRow.fileName, `file-${fileRow.id}`),
+                    fileType: fileRow.fileType,
+                    fileSize: fileRow.fileSize,
+                    purpose: fileRow.purpose,
+                    status: fileRow.status,
+                    uploadedBy: typeof fileRow.userId === 'number' ? userPreviewById.get(fileRow.userId) || null : null,
+                    agent: typeof fileRow.agentId === 'number' ? agentPreviewById.get(fileRow.agentId) || null : null,
+                    attachedToMessages,
+                    contentUrl,
+                    contentIncluded: Boolean(downloadResult.content),
+                    ...(downloadResult.error ? { contentDownloadError: downloadResult.error } : {}),
+                },
+                null,
+                2,
+            )}\n`,
+        );
+    }
+
+    for (const imageRow of imageRows) {
+        const filename = createUniqueBackupFilename(
+            usedImageFilenames,
+            resolveBinaryBackupFilename(imageRow.filename, imageRow.cdnUrl, `image-${imageRow.id}`),
+            `image-${imageRow.id}`,
+        );
+        const downloadResult = await downloadBackupBinaryContent(imageRow.cdnUrl);
+
+        if (downloadResult.content) {
+            zip.file(`${imagesRootPath}/${filename}`, downloadResult.content);
+        }
+
+        zip.file(
+            `${imagesRootPath}/${createBinaryMetadataFilename(filename)}`,
+            `${JSON.stringify(
+                {
+                    kind: 'generated-image',
+                    id: imageRow.id,
+                    createdAt: imageRow.createdAt,
+                    updatedAt: imageRow.updatedAt,
+                    filename: imageRow.filename,
+                    prompt: imageRow.prompt,
+                    purpose: imageRow.purpose,
+                    agent: typeof imageRow.agentId === 'number' ? agentPreviewById.get(imageRow.agentId) || null : null,
+                    contentUrl: imageRow.cdnUrl,
+                    contentIncluded: Boolean(downloadResult.content),
+                    ...(downloadResult.error ? { contentDownloadError: downloadResult.error } : {}),
+                },
+                null,
+                2,
+            )}\n`,
+        );
+    }
+}

package/apps/agents-server/src/utils/backup/serverBackup/appendMessageBackupEntriesToZip.ts

@@ -0,0 +1,65 @@
+import JSZip from 'jszip';
+import { loadTableRows, type ServerBackupContext } from './serverBackupContext';
+import { createBackupStem, createUniqueBackupFilename, ensureJsonFilename } from './serverBackupFilenames';
+import { groupRowsBy } from './serverBackupRowUtilities';
+
+/**
+ * Writes one JSON file per system message with delivery history.
+ *
+ * @param zip - ZIP archive being assembled.
+ * @param sectionRootPath - Root path for the messages section.
+ * @param context - Shared backup context.
+ *
+ * @private function of `createServerBackupZipStream`
+ */
+export async function appendMessageBackupEntriesToZip(
+    zip: JSZip,
+    sectionRootPath: string,
+    context: ServerBackupContext,
+): Promise<void> {
+    const [messageRows, sendAttemptRows] = await Promise.all([
+        loadTableRows(context.supabase, 'Message'),
+        loadTableRows(context.supabase, 'MessageSendAttempt'),
+    ]);
+    const usedMessageFilenames = new Set<string>();
+    const sendAttemptsByMessageId = groupRowsBy(sendAttemptRows, (row) => row.messageId);
+
+    for (const messageRow of messageRows) {
+        const filename = createUniqueBackupFilename(
+            usedMessageFilenames,
+            ensureJsonFilename(
+                createBackupStem(
+                    [messageRow.channel, messageRow.direction, messageRow.createdAt],
+                    `message-${messageRow.id}`,
+                ),
+            ),
+            `message-${messageRow.id}`,
+        );
+        const sendAttempts = sendAttemptsByMessageId.get(messageRow.id) || [];
+
+        zip.file(
+            `${sectionRootPath}/${filename}`,
+            `${JSON.stringify(
+                {
+                    id: messageRow.id,
+                    createdAt: messageRow.createdAt,
+                    channel: messageRow.channel,
+                    direction: messageRow.direction,
+                    sender: messageRow.sender,
+                    recipients: messageRow.recipients,
+                    content: messageRow.content,
+                    threadId: messageRow.threadId,
+                    metadata: messageRow.metadata,
+                    sendAttempts: sendAttempts.map((row) => ({
+                        id: row.id,
+                        createdAt: row.createdAt,
+                        providerName: row.providerName,
+                        isSuccessful: row.isSuccessful,
+                    })),
+                },
+                null,
+                2,
+            )}\n`,
+        );
+    }
+}

package/apps/agents-server/src/utils/backup/serverBackup/appendMetadataBackupEntriesToZip.ts

@@ -0,0 +1,39 @@
+import JSZip from 'jszip';
+import { loadTableRows, type ServerBackupContext } from './serverBackupContext';
+
+/**
+ * Filename used for the flattened metadata and limits export.
+ *
+ * @private constant of `createServerBackupZipStream`
+ */
+const METADATA_AND_LIMITS_FILENAME = 'metadata-and-limits.json';
+
+/**
+ * Writes the flattened metadata and limits file.
+ *
+ * @param zip - ZIP archive being assembled.
+ * @param sectionRootPath - Root path for the metadata section.
+ * @param context - Shared backup context.
+ *
+ * @private function of `createServerBackupZipStream`
+ */
+export async function appendMetadataBackupEntriesToZip(
+    zip: JSZip,
+    sectionRootPath: string,
+    context: ServerBackupContext,
+): Promise<void> {
+    const [metadataRows, serverLimitRows] = await Promise.all([
+        loadTableRows(context.supabase, 'Metadata'),
+        loadTableRows(context.supabase, 'ServerLimit'),
+    ]);
+
+    const keyValueEntries = [
+        ...metadataRows.map((row) => [row.key, row.value] as const),
+        ...serverLimitRows.map((row) => [row.key, row.value] as const),
+    ].sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey));
+
+    zip.file(
+        `${sectionRootPath}/${METADATA_AND_LIMITS_FILENAME}`,
+        `${JSON.stringify(Object.fromEntries(keyValueEntries), null, 2)}\n`,
+    );
+}

package/apps/agents-server/src/utils/backup/serverBackup/appendSectionEntriesToZip.ts

@@ -0,0 +1,92 @@
+import JSZip from 'jszip';
+import type { ServerBackupSectionDefinition } from '../serverBackupSections';
+import { appendAgentBackupEntriesToZip } from './appendAgentBackupEntriesToZip';
+import { appendConversationBackupEntriesToZip } from './appendConversationBackupEntriesToZip';
+import { appendFileBackupEntriesToZip } from './appendFileBackupEntriesToZip';
+import { appendMessageBackupEntriesToZip } from './appendMessageBackupEntriesToZip';
+import { appendMetadataBackupEntriesToZip } from './appendMetadataBackupEntriesToZip';
+import { appendUserBackupEntriesToZip } from './appendUserBackupEntriesToZip';
+import type { ServerBackupContext } from './serverBackupContext';
+
+/**
+ * Filename used when a requested section intentionally exports no data.
+ *
+ * @private constant of `createServerBackupZipStream`
+ */
+const EXCLUDED_SECTION_FILENAME = 'excluded.json';
+
+/**
+ * Appends one selected section into the ZIP archive.
+ *
+ * @param options - Section append options.
+ *
+ * @private function of `createServerBackupZipStream`
+ */
+export async function appendSectionEntriesToZip(options: {
+    zip: JSZip;
+    backupRootFolderName: string;
+    sectionDefinition: ServerBackupSectionDefinition;
+    context: ServerBackupContext;
+}): Promise<void> {
+    const { zip, backupRootFolderName, sectionDefinition, context } = options;
+    const sectionRootPath = `${backupRootFolderName}/data/${sectionDefinition.directoryName}`;
+    zip.folder(sectionRootPath);
+
+    switch (sectionDefinition.key) {
+        case 'metadata':
+            await appendMetadataBackupEntriesToZip(zip, sectionRootPath, context);
+            return;
+        case 'agents':
+            await appendAgentBackupEntriesToZip(zip, sectionRootPath, sectionDefinition, context);
+            return;
+        case 'conversations':
+            await appendConversationBackupEntriesToZip(zip, sectionRootPath, context);
+            return;
+        case 'users':
+            await appendUserBackupEntriesToZip(zip, sectionRootPath, context);
+            return;
+        case 'files':
+            await appendFileBackupEntriesToZip(zip, sectionRootPath, context);
+            return;
+        case 'messages':
+            await appendMessageBackupEntriesToZip(zip, sectionRootPath, context);
+            return;
+        case 'security':
+        case 'caches':
+            appendExcludedSectionNoteToZip(zip, sectionRootPath, sectionDefinition);
+            return;
+        default: {
+            const exhaustiveSectionKey: never = sectionDefinition.key;
+            throw new Error(`Unsupported backup section ${String(exhaustiveSectionKey)}.`);
+        }
+    }
+}
+
+/**
+ * Writes the explanatory note for a section that is intentionally excluded from the archive.
+ *
+ * @param zip - ZIP archive being assembled.
+ * @param sectionRootPath - Root path for the excluded section.
+ * @param sectionDefinition - Excluded section definition.
+ *
+ * @private function of `createServerBackupZipStream`
+ */
+function appendExcludedSectionNoteToZip(
+    zip: JSZip,
+    sectionRootPath: string,
+    sectionDefinition: ServerBackupSectionDefinition,
+): void {
+    zip.file(
+        `${sectionRootPath}/${EXCLUDED_SECTION_FILENAME}`,
+        `${JSON.stringify(
+            {
+                key: sectionDefinition.key,
+                label: sectionDefinition.label,
+                included: false,
+                reason: sectionDefinition.description,
+            },
+            null,
+            2,
+        )}\n`,
+    );
+}

package/apps/agents-server/src/utils/backup/serverBackup/appendUserBackupEntriesToZip.ts

@@ -0,0 +1,80 @@
+import JSZip from 'jszip';
+import { createRedactedWalletBackupRecord } from './createRedactedWalletBackupRecord';
+import { loadAgentRows, loadTableRows, loadUserRows, type ServerBackupContext } from './serverBackupContext';
+import { createBackupStem, createUniqueBackupFilename, ensureJsonFilename } from './serverBackupFilenames';
+import { createAgentPreviewByPermanentId } from './serverBackupPreviews';
+import { groupRowsBy } from './serverBackupRowUtilities';
+
+/**
+ * Writes one JSON file per user with related memories, structured data, and redacted wallet entries.
+ *
+ * @param zip - ZIP archive being assembled.
+ * @param sectionRootPath - Root path for the users section.
+ * @param context - Shared backup context.
+ *
+ * @private function of `createServerBackupZipStream`
+ */
+export async function appendUserBackupEntriesToZip(
+    zip: JSZip,
+    sectionRootPath: string,
+    context: ServerBackupContext,
+): Promise<void> {
+    const [users, agents, memoryRows, userDataRows, walletRows] = await Promise.all([
+        loadUserRows(context),
+        loadAgentRows(context),
+        loadTableRows(context.supabase, 'UserMemory'),
+        loadTableRows(context.supabase, 'UserData'),
+        loadTableRows(context.supabase, 'Wallet'),
+    ]);
+    const usedUserFilenames = new Set<string>();
+    const agentPreviewByPermanentId = createAgentPreviewByPermanentId(agents);
+    const memoryRowsByUserId = groupRowsBy(memoryRows, (row) => row.userId);
+    const userDataRowsByUserId = groupRowsBy(userDataRows, (row) => row.userId);
+    const walletRowsByUserId = groupRowsBy(walletRows, (row) => row.userId);
+
+    for (const user of users) {
+        const filename = createUniqueBackupFilename(
+            usedUserFilenames,
+            ensureJsonFilename(createBackupStem([user.username], `user-${user.id}`)),
+            `user-${user.id}`,
+        );
+        const userMemoryRows = memoryRowsByUserId.get(user.id) || [];
+        const scopedUserDataRows = userDataRowsByUserId.get(user.id) || [];
+        const scopedWalletRows = walletRowsByUserId.get(user.id) || [];
+
+        zip.file(
+            `${sectionRootPath}/${filename}`,
+            `${JSON.stringify(
+                {
+                    user: {
+                        id: user.id,
+                        createdAt: user.createdAt,
+                        updatedAt: user.updatedAt,
+                        username: user.username,
+                        isAdmin: user.isAdmin,
+                        profileImageUrl: user.profileImageUrl,
+                    },
+                    memories: userMemoryRows.map((row) => ({
+                        id: row.id,
+                        createdAt: row.createdAt,
+                        updatedAt: row.updatedAt,
+                        content: row.content,
+                        isGlobal: row.isGlobal,
+                        deletedAt: row.deletedAt,
+                        agent: row.agentPermanentId ? agentPreviewByPermanentId.get(row.agentPermanentId) || null : null,
+                    })),
+                    data: scopedUserDataRows.map((row) => ({
+                        id: row.id,
+                        createdAt: row.createdAt,
+                        updatedAt: row.updatedAt,
+                        key: row.key,
+                        value: row.value,
+                    })),
+                    wallet: scopedWalletRows.map((row) => createRedactedWalletBackupRecord(row, agentPreviewByPermanentId)),
+                },
+                null,
+                2,
+            )}\n`,
+        );
+    }
+}

package/apps/agents-server/src/utils/backup/serverBackup/createRedactedWalletBackupRecord.ts

@@ -0,0 +1,34 @@
+import { normalizeOptionalText } from './serverBackupRowUtilities';
+import type { BackupAgentPreview, WalletRow } from './serverBackupTypes';
+
+/**
+ * Creates the redacted wallet representation written into per-user backups.
+ *
+ * @param walletRow - Persisted wallet row.
+ * @param agentPreviewByPermanentId - Agent preview lookup for scoped records.
+ * @returns Redacted wallet record safe for backup export.
+ *
+ * @private function of `createServerBackupZipStream`
+ */
+export function createRedactedWalletBackupRecord(
+    walletRow: WalletRow,
+    agentPreviewByPermanentId: ReadonlyMap<string, BackupAgentPreview>,
+): Record<string, unknown> {
+    return {
+        id: walletRow.id,
+        createdAt: walletRow.createdAt,
+        updatedAt: walletRow.updatedAt,
+        isUserScoped: walletRow.isUserScoped,
+        isGlobal: walletRow.isGlobal,
+        deletedAt: walletRow.deletedAt,
+        recordType: walletRow.recordType,
+        service: walletRow.service,
+        key: walletRow.key,
+        jsonSchema: walletRow.jsonSchema,
+        username: walletRow.username,
+        agent: walletRow.agentPermanentId ? agentPreviewByPermanentId.get(walletRow.agentPermanentId) || null : null,
+        hasPassword: Boolean(normalizeOptionalText(walletRow.password)),
+        hasSecret: Boolean(normalizeOptionalText(walletRow.secret)),
+        hasCookies: Boolean(normalizeOptionalText(walletRow.cookies)),
+    };
+}