@promptbook/cli 0.112.0-101 → 0.112.0-102

package/apps/agents-server/src/languages/translations/english.yaml

@@ -124,6 +124,7 @@ header.menuLabel: Menu
 header.myAccount: My Account
 header.superAdmin: Super Admin
 header.administration: Administration
+header.loginMethods: Login Methods
 header.monitoringAndUsage: Monitoring & Usage
 header.integrationsAndKeys: Integrations & Keys
 header.developerDebug: Developer / Debug
@@ -164,6 +165,7 @@ header.errorSimulation: Error simulation
 header.imagesGallery: Images gallery
 header.files: Files
 header.users: Users
+header.shibboleth: Shibboleth
 header.versionInfo: Version info
 header.experiments: Experiments
 header.story: Story
@@ -194,8 +196,8 @@ login.passwordLabel: Password
 login.passwordPlaceholder: Enter your password
 login.loggingIn: Logging in...
 login.loginAction: Log in
-login.shibbolethAction: Continue with {provider}
-login.methodDivider: or
+login.shibbolethLoginAction: Continue with Shibboleth
+login.shibbolethNotConfigured: Shibboleth login is active but needs administrator setup.
 login.forgottenPassword: Forgotten password?
 login.registerNewUser: Register new user
 login.errorOccurred: An error occurred
@@ -382,7 +384,7 @@ footer.logosAndBranding: Logos & Branding
 footer.connectSectionTitle: Connect
 footer.linksSectionTitle: Links
 footer.allRightsReserved: All rights reserved.
-footer.madeInCzechRepublic: Made with ❤️ in the Czech Republic.
+footer.madeInCzechRepublic: Made with ❤️ in the Czech Republic
 footer.engineVersion: Promptbook engine version
 forbidden.title: 403 Forbidden
 forbidden.message: You do not have permission to access this page.

package/apps/agents-server/src/tools/$provideCdnForServer.ts

@@ -1,43 +1,89 @@
 import { $provideSupabaseForServer } from '../database/$provideSupabaseForServer';
+import { DigitalOceanSpaces } from '../utils/cdn/classes/DigitalOceanSpaces';
 import { TrackedFilesStorage } from '../utils/cdn/classes/TrackedFilesStorage';
 import { VercelBlobStorage } from '../utils/cdn/classes/VercelBlobStorage';
 import { IIFilesStorageWithCdn } from '../utils/cdn/interfaces/IFilesStorage';
+import { resolveCdnStorageProvider } from '../utils/cdn/resolveCdnStorageProvider';
 
 /**
- * Cache of CDN instance
+ * Environment value that enables path-style S3 requests.
  *
  * @private internal cache for `$provideCdnForServer`
  */
-let cdn: IIFilesStorageWithCdn | null = null;
+const TRUE_ENV_VALUE = 'true';
+
+/**
+ * Cache of raw CDN instance.
+ *
+ * @private internal cache for `$provideCdnForServer`
+ */
+let rawCdn: IIFilesStorageWithCdn | null = null;
+
+/**
+ * Cache of tracked CDN instance.
+ *
+ * @private internal cache for `$provideCdnForServer`
+ */
+let trackedCdn: IIFilesStorageWithCdn | null = null;
+
+/**
+ * Creates a CDN storage instance from environment variables.
+ *
+ * @private internal factory for `$provideCdnForServer`
+ */
+function createCdnForServer(): IIFilesStorageWithCdn {
+    const provider = resolveCdnStorageProvider();
+
+    switch (provider) {
+        case 's3':
+            return new DigitalOceanSpaces({
+                bucket: process.env.CDN_BUCKET!,
+                pathPrefix: process.env.NEXT_PUBLIC_CDN_PATH_PREFIX || '',
+                endpoint: process.env.CDN_ENDPOINT!,
+                region: process.env.CDN_REGION || 'auto',
+                accessKeyId: process.env.CDN_ACCESS_KEY_ID!,
+                secretAccessKey: process.env.CDN_SECRET_ACCESS_KEY!,
+                cdnPublicUrl: new URL(process.env.NEXT_PUBLIC_CDN_PUBLIC_URL!),
+                gzip: process.env.CDN_GZIP !== 'false',
+                forcePathStyle: process.env.CDN_FORCE_PATH_STYLE === TRUE_ENV_VALUE,
+                isPublicReadAclEnabled: process.env.CDN_ENABLE_PUBLIC_READ_ACL !== 'false',
+            });
+
+        case 'vercel':
+            return new VercelBlobStorage({
+                token: process.env.VERCEL_BLOB_READ_WRITE_TOKEN!,
+                pathPrefix: process.env.NEXT_PUBLIC_CDN_PATH_PREFIX!,
+                cdnPublicUrl: new URL(process.env.NEXT_PUBLIC_CDN_PUBLIC_URL!),
+            });
+    }
+}
+
+/**
+ * Provides an untracked CDN storage interface for code paths that manage `File` rows themselves.
+ *
+ * @private internal cache for `$provideCdnForServer`
+ */
+export function $provideUntrackedCdnForServer(): IIFilesStorageWithCdn {
+    if (!rawCdn) {
+        rawCdn = createCdnForServer();
+    }
+
+    return rawCdn;
+}
 
 /**
  * Provides a CDN storage interface for server-side file operations, with caching to reuse instances.
+ *
+ * @private internal cache for `$provideCdnForServer`
  */
 export function $provideCdnForServer(): IIFilesStorageWithCdn {
-    if (!cdn) {
-        const inner = new VercelBlobStorage({
-            token: process.env.VERCEL_BLOB_READ_WRITE_TOKEN!,
-            pathPrefix: process.env.NEXT_PUBLIC_CDN_PATH_PREFIX!,
-            cdnPublicUrl: new URL(process.env.NEXT_PUBLIC_CDN_PUBLIC_URL!),
-        });
-
+    if (!trackedCdn) {
+        const inner = $provideUntrackedCdnForServer();
         const supabase = $provideSupabaseForServer();
-        cdn = new TrackedFilesStorage(inner, supabase);
-
-        /*
-        cdn = new DigitalOceanSpaces({
-            bucket: process.env.CDN_BUCKET!,
-            pathPrefix: process.env.NEXT_PUBLIC_CDN_PATH_PREFIX!,
-            endpoint: process.env.CDN_ENDPOINT!,
-            accessKeyId: process.env.CDN_ACCESS_KEY_ID!,
-            secretAccessKey: process.env.CDN_SECRET_ACCESS_KEY!,
-            cdnPublicUrl: new URL(process.env.NEXT_PUBLIC_CDN_PUBLIC_URL!),
-            gzip: true,
-        });
-        */
+        trackedCdn = new TrackedFilesStorage(inner, supabase);
     }
 
-    return cdn;
+    return trackedCdn;
 }
 
 // TODO: [🏓] Unite `xxxForServer` and `xxxForNode` naming

package/apps/agents-server/src/utils/cdn/classes/DigitalOceanSpaces.ts

@@ -12,14 +12,45 @@ type IDigitalOceanSpacesConfig = {
     readonly bucket: string;
     readonly pathPrefix: string;
     readonly endpoint: string;
+    readonly region?: string;
     readonly accessKeyId: string;
     readonly secretAccessKey: string;
     readonly cdnPublicUrl: URL;
     readonly gzip: boolean;
+    readonly forcePathStyle?: boolean;
+    readonly isPublicReadAclEnabled?: boolean;
 
     // TODO: [⛳️] Probbably prefix should be in this config not on the consumer side
 };
 
+/**
+ * Resolves the S3 endpoint URL, preserving explicit `http` endpoints for local MinIO.
+ *
+ * @private internal helper for DigitalOceanSpaces.
+ */
+function resolveS3Endpoint(endpoint: string): string {
+    if (/^https?:\/\//i.test(endpoint)) {
+        return endpoint;
+    }
+
+    return `https://${endpoint}`;
+}
+
+/**
+ * Returns a URL object whose pathname ends with `/`.
+ *
+ * @private internal helper for DigitalOceanSpaces.
+ */
+function ensureTrailingSlashUrl(url: URL): URL {
+    const normalizedUrl = new URL(url.href);
+
+    if (!normalizedUrl.pathname.endsWith('/')) {
+        normalizedUrl.pathname = `${normalizedUrl.pathname}/`;
+    }
+
+    return normalizedUrl;
+}
+
 /**
  * Class implementing digital ocean spaces.
  */
@@ -32,8 +63,9 @@ export class DigitalOceanSpaces implements IIFilesStorageWithCdn {
 
     public constructor(private readonly config: IDigitalOceanSpacesConfig) {
         this.s3 = new S3Client({
-            region: 'auto',
-            endpoint: 'https://' + config.endpoint,
+            region: config.region || 'auto',
+            endpoint: resolveS3Endpoint(config.endpoint),
+            forcePathStyle: config.forcePathStyle,
             credentials: {
                 accessKeyId: config.accessKeyId,
                 secretAccessKey: config.secretAccessKey,
@@ -42,13 +74,13 @@ export class DigitalOceanSpaces implements IIFilesStorageWithCdn {
     }
 
     public getItemUrl(key: string): URL {
-        return new URL(this.config.pathPrefix + '/' + key, this.cdnPublicUrl);
+        return new URL(this.getStorageKey(key), ensureTrailingSlashUrl(this.cdnPublicUrl));
     }
 
     public async getItem(key: string): Promise<IFile | null> {
         const parameters = {
             Bucket: this.config.bucket,
-            Key: this.config.pathPrefix + '/' + key,
+            Key: this.getStorageKey(key),
         };
 
         try {
@@ -104,12 +136,12 @@ export class DigitalOceanSpaces implements IIFilesStorageWithCdn {
         const uploadResult = await this.s3.send(
             new PutObjectCommand({
                 Bucket: this.config.bucket,
-                Key: this.config.pathPrefix + '/' + key,
+                Key: this.getStorageKey(key),
                 ContentType: processedFile.type,
                 ...putObjectRequestAdditional,
                 Body: processedFile.data,
                 // TODO: Public read access / just private to extending class
-                ACL: 'public-read',
+                ...(this.config.isPublicReadAclEnabled === false ? {} : { ACL: 'public-read' }),
             }),
         );
 
@@ -117,6 +149,22 @@ export class DigitalOceanSpaces implements IIFilesStorageWithCdn {
             throw new Error(`Upload result does not contain ETag`);
         }
     }
+
+    /**
+     * Builds the final object key used in the S3 bucket.
+     *
+     * @private internal helper for DigitalOceanSpaces.
+     */
+    private getStorageKey(key: string): string {
+        const normalizedKey = key.replace(/^\/+/g, '');
+        const normalizedPathPrefix = this.config.pathPrefix.replace(/^\/+|\/+$/g, '');
+
+        if (!normalizedPathPrefix) {
+            return normalizedKey;
+        }
+
+        return `${normalizedPathPrefix}/${normalizedKey}`;
+    }
 }
 
 // TODO: Implement Read-only mode

package/apps/agents-server/src/utils/cdn/classes/TrackedFilesStorage.ts

@@ -33,24 +33,22 @@ export class TrackedFilesStorage implements IIFilesStorageWithCdn {
     }
 
     public async setItem(key: string, file: IFile): Promise<void> {
-
         await this.inner.setItem(key, file);
 
         try {
             const { userId, purpose } = file;
-            const cdnUrl = this.getItemUrl(key).href;
+            const storageUrl = this.getItemUrl(key).href;
 
-     
             await this.supabase.from(await $getTableName('File')).insert({
                 userId: userId || null,
                 fileName: key,
                 fileSize: file.fileSize ?? file.data.length,
                 fileType: file.type,
-                cdnUrl,
+                storageUrl,
+                shortUrl: null,
                 purpose: purpose || 'UNKNOWN',
+                status: 'COMPLETED',
             });
-
-           
         } catch (error) {
             console.error('Failed to track upload:', error);
         }

package/apps/agents-server/src/utils/cdn/resolveCdnStorageProvider.ts

@@ -0,0 +1,40 @@
+/**
+ * Supported file storage backends for Agents Server CDN uploads.
+ *
+ * @private internal CDN configuration helper.
+ */
+export type CdnStorageProvider = 's3' | 'vercel';
+
+/**
+ * Resolves the configured CDN storage provider.
+ *
+ * @private internal CDN configuration helper.
+ */
+export function resolveCdnStorageProvider(): CdnStorageProvider {
+    const rawProvider = (process.env.NEXT_PUBLIC_CDN_STORAGE_PROVIDER || '').trim().toLowerCase();
+
+    switch (rawProvider) {
+        case 's3':
+        case 'minio':
+        case 'external-s3':
+        case 'self-contained-s3':
+            return 's3';
+
+        case 'vercel':
+        case 'vercel-blob':
+        case '':
+            return 'vercel';
+
+        default:
+            throw new Error(`Unsupported CDN storage provider \`${rawProvider}\`.`);
+    }
+}
+
+/**
+ * Checks whether browser uploads should be routed through the Agents Server API.
+ *
+ * @private internal CDN configuration helper.
+ */
+export function isServerRoutedCdnUploadProvider(provider: CdnStorageProvider = resolveCdnStorageProvider()): boolean {
+    return provider === 's3';
+}

package/apps/agents-server/src/utils/chatExport/renderHtmlToPdfOnServer.ts

@@ -9,6 +9,16 @@ const CHAT_EXPORT_PDF_VIEWPORT = {
     height: 1600,
 } as const;
 
+/**
+ * Page margins applied to every exported PDF page.
+ */
+const CHAT_EXPORT_PDF_MARGIN = {
+    top: '0.5in',
+    right: '0.5in',
+    bottom: '0.5in',
+    left: '0.5in',
+} as const;
+
 /**
  * Prints standalone HTML into a PDF using a short-lived headless Chromium instance.
  *
@@ -31,6 +41,7 @@ export async function renderHtmlToPdfOnServer(html: string): Promise<Buffer> {
 
             return await page.pdf({
                 format: 'Letter',
+                margin: CHAT_EXPORT_PDF_MARGIN,
                 printBackground: true,
                 preferCSSPageSize: true,
             });

package/apps/agents-server/src/utils/createAdminTerminalRouteHandlers.ts

@@ -0,0 +1,264 @@
+import { NextResponse } from 'next/server';
+import { createInteractiveTerminalEventStream } from './createInteractiveTerminalEventStream';
+import { isUserGlobalAdmin } from './isUserGlobalAdmin';
+import type { InteractiveTerminalSessionSubscriber } from './interactiveTerminalSession';
+
+/**
+ * Minimal browser-safe terminal session shape handled by the shared admin API routes.
+ */
+type AdminTerminalRouteSession = {
+    /**
+     * Whether the terminal process is still active.
+     */
+    readonly isRunning: boolean;
+};
+
+/**
+ * Browser stream callbacks accepted by one admin terminal route.
+ */
+type AdminTerminalRouteSubscriber<TSession extends AdminTerminalRouteSession> = {
+    /**
+     * Called whenever the terminal backend emits output.
+     */
+    readonly onOutput: InteractiveTerminalSessionSubscriber['onOutput'];
+
+    /**
+     * Called once the terminal backend exits.
+     */
+    readonly onExit: (event: { readonly type: 'exit'; readonly snapshot: TSession }) => void;
+};
+
+/**
+ * Terminal backend operations provided by each specific admin terminal.
+ */
+type AdminTerminalRouteBackend<TSession extends AdminTerminalRouteSession> = {
+    /**
+     * Returns the latest session for the terminal purpose.
+     */
+    readonly getLatestSession: (request: Request) => Promise<TSession | null> | TSession | null;
+
+    /**
+     * Looks up one session by id.
+     */
+    readonly getSession: (sessionId: string) => Promise<TSession | null> | TSession | null;
+
+    /**
+     * Starts or reconnects to the terminal session.
+     */
+    readonly startSession: (request: Request) => Promise<TSession> | TSession;
+
+    /**
+     * Sends raw input to the terminal session.
+     */
+    readonly writeSessionInput: (sessionId: string, input: string) => Promise<TSession> | TSession;
+
+    /**
+     * Stops one terminal session.
+     */
+    readonly stopSession: (sessionId: string) => Promise<TSession> | TSession;
+
+    /**
+     * Subscribes one browser stream to live terminal events.
+     */
+    readonly subscribeToSession: (
+        sessionId: string,
+        subscriber: AdminTerminalRouteSubscriber<TSession>,
+    ) => (() => void) | null;
+};
+
+/**
+ * User-facing error messages used by the generated terminal route handlers.
+ */
+type AdminTerminalRouteMessages = {
+    /**
+     * Error used when loading the latest session fails.
+     */
+    readonly loadErrorMessage: string;
+
+    /**
+     * Error used when the stream request omits a session id.
+     */
+    readonly missingStreamSessionIdMessage: string;
+
+    /**
+     * Error used when the requested stream session does not exist.
+     */
+    readonly sessionNotFoundMessage: string;
+
+    /**
+     * Error used when starting a session fails.
+     */
+    readonly startErrorMessage: string;
+
+    /**
+     * Error used when the input request is malformed.
+     */
+    readonly missingInputMessage: string;
+
+    /**
+     * Error used when writing input fails.
+     */
+    readonly sendErrorMessage: string;
+
+    /**
+     * Error used when the stop request omits a session id.
+     */
+    readonly missingStopSessionIdMessage: string;
+
+    /**
+     * Error used when stopping a session fails.
+     */
+    readonly stopErrorMessage: string;
+};
+
+/**
+ * Generated Next.js route handlers for one admin terminal endpoint.
+ */
+type AdminTerminalRouteHandlers = {
+    /**
+     * Loads the latest terminal session or streams a specific session.
+     */
+    readonly GET: (request: Request) => Promise<Response>;
+
+    /**
+     * Starts or reconnects to the terminal session.
+     */
+    readonly POST: (request: Request) => Promise<Response>;
+
+    /**
+     * Sends raw input to a running terminal session.
+     */
+    readonly PATCH: (request: Request) => Promise<Response>;
+
+    /**
+     * Stops one terminal session.
+     */
+    readonly DELETE: (request: Request) => Promise<Response>;
+};
+
+/**
+ * Creates consistent admin terminal API handlers for GET/stream, POST, PATCH, and DELETE.
+ *
+ * @param backend - Terminal-specific backend operations.
+ * @param messages - Terminal-specific error messages.
+ * @returns Next.js route handlers ready to export from an API route.
+ */
+export function createAdminTerminalRouteHandlers<TSession extends AdminTerminalRouteSession>(
+    backend: AdminTerminalRouteBackend<TSession>,
+    messages: AdminTerminalRouteMessages,
+): AdminTerminalRouteHandlers {
+    return {
+        async GET(request: Request): Promise<Response> {
+            if (!(await isUserGlobalAdmin())) {
+                return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+            }
+
+            try {
+                const { searchParams } = new URL(request.url);
+                const sessionId = searchParams.get('sessionId')?.trim() || '';
+                const isStreamRequested = searchParams.get('stream') === '1';
+
+                if (isStreamRequested) {
+                    if (!sessionId) {
+                        return NextResponse.json({ error: messages.missingStreamSessionIdMessage }, { status: 400 });
+                    }
+
+                    const session = await backend.getSession(sessionId);
+                    if (!session) {
+                        return NextResponse.json({ error: messages.sessionNotFoundMessage }, { status: 404 });
+                    }
+
+                    return createInteractiveTerminalEventStream(
+                        request,
+                        sessionId,
+                        session,
+                        backend.subscribeToSession,
+                    );
+                }
+
+                return NextResponse.json({
+                    session: await backend.getLatestSession(request),
+                });
+            } catch (error) {
+                return createAdminTerminalErrorResponse(error, messages.loadErrorMessage);
+            }
+        },
+
+        async POST(request: Request): Promise<Response> {
+            if (!(await isUserGlobalAdmin())) {
+                return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+            }
+
+            try {
+                return NextResponse.json({
+                    session: await backend.startSession(request),
+                });
+            } catch (error) {
+                return createAdminTerminalErrorResponse(error, messages.startErrorMessage);
+            }
+        },
+
+        async PATCH(request: Request): Promise<Response> {
+            if (!(await isUserGlobalAdmin())) {
+                return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+            }
+
+            try {
+                const body = (await request.json().catch(() => null)) as
+                    | {
+                          readonly sessionId?: string;
+                          readonly input?: string;
+                      }
+                    | null;
+
+                if (!body?.sessionId || typeof body.input !== 'string') {
+                    return NextResponse.json({ error: messages.missingInputMessage }, { status: 400 });
+                }
+
+                return NextResponse.json({
+                    session: await backend.writeSessionInput(body.sessionId, body.input),
+                });
+            } catch (error) {
+                return createAdminTerminalErrorResponse(error, messages.sendErrorMessage);
+            }
+        },
+
+        async DELETE(request: Request): Promise<Response> {
+            if (!(await isUserGlobalAdmin())) {
+                return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+            }
+
+            try {
+                const body = (await request.json().catch(() => null)) as
+                    | {
+                          readonly sessionId?: string;
+                      }
+                    | null;
+
+                if (!body?.sessionId) {
+                    return NextResponse.json({ error: messages.missingStopSessionIdMessage }, { status: 400 });
+                }
+
+                return NextResponse.json({
+                    session: await backend.stopSession(body.sessionId),
+                });
+            } catch (error) {
+                return createAdminTerminalErrorResponse(error, messages.stopErrorMessage);
+            }
+        },
+    };
+}
+
+/**
+ * Converts one thrown backend failure into a consistent JSON error response.
+ *
+ * @param error - Thrown backend error.
+ * @param fallbackMessage - Message used when the thrown value is not an `Error`.
+ * @returns JSON error response.
+ */
+function createAdminTerminalErrorResponse(error: unknown, fallbackMessage: string): Response {
+    return NextResponse.json(
+        { error: error instanceof Error ? error.message : fallbackMessage },
+        { status: 500 },
+    );
+}

package/apps/agents-server/src/utils/shareTargetPayloads.ts

@@ -2,12 +2,12 @@ import { $getTableName } from '@/src/database/$getTableName';
 import { $provideSupabaseForServer } from '@/src/database/$provideSupabaseForServer';
 import type { Json } from '@/src/database/schema';
 import { FILE_SECURITY_CHECKERS } from '@/src/file-security-checkers';
+import { $provideUntrackedCdnForServer } from '@/src/tools/$provideCdnForServer';
 import { $provideServer } from '@/src/tools/$provideServer';
 import { getUserFileCdnKey } from '@/src/utils/cdn/utils/getUserFileCdnKey';
 import { validateMimeType } from '@/src/utils/validators/validateMimeType';
 import { normalizeChatAttachments } from '@promptbook-local/core';
 import type { TODO_any } from '@promptbook-local/types';
-import { put } from '@vercel/blob';
 import { after } from 'next/server';
 import { spaceTrim } from 'spacetrim';
 import { DatabaseError } from '../../../../src/errors/DatabaseError';
@@ -231,12 +231,12 @@ async function createShareTargetAttachment(file: File, maxFileUploadBytes: numbe
 
     const mimeType = resolveShareTargetMimeType(file.type);
     const blobPath = getUserFileCdnKey(buffer, normalizedFilename);
-    const uploadedBlob = await put(blobPath, buffer, {
-        access: 'public',
-        addRandomSuffix: false,
-        allowOverwrite: true,
-        contentType: mimeType,
-        token: process.env.VERCEL_BLOB_READ_WRITE_TOKEN!,
+    const cdn = $provideUntrackedCdnForServer();
+    await cdn.setItem(blobPath, {
+        data: buffer,
+        type: mimeType,
+        fileSize: buffer.byteLength,
+        purpose: SHARE_TARGET_FILE_PURPOSE,
     }).catch((error) => {
         throw new DatabaseError(
             spaceTrim(`
@@ -246,18 +246,19 @@ async function createShareTargetAttachment(file: File, maxFileUploadBytes: numbe
             `),
         );
     });
+    const storageUrl = cdn.getItemUrl(blobPath).href;
     const fileRecordId = await insertShareTargetFileRecord({
         fileName: normalizedFilename,
         fileSize: buffer.byteLength,
         fileType: mimeType,
-        storageUrl: uploadedBlob.url,
+        storageUrl,
     });
 
     if (fileRecordId !== null) {
         after(() =>
             populateShareTargetFileSecurityResult({
                 fileId: fileRecordId,
-                storageUrl: uploadedBlob.url,
+                storageUrl,
             }).catch((error) => {
                 console.error('[share-target] Failed to finalize file security result', error);
             }),
@@ -267,7 +268,7 @@ async function createShareTargetAttachment(file: File, maxFileUploadBytes: numbe
     return {
         name: normalizedFilename,
         type: mimeType,
-        url: uploadedBlob.url,
+        url: storageUrl,
     };
 }