@promptbook/cli 0.104.0-0 → 0.104.0-10

package/apps/agents-server/src/app/agents/[agentName]/website-integration/page.tsx

@@ -7,8 +7,9 @@ import { parseAgentSource } from '@promptbook-local/core';
 import { headers } from 'next/headers';
 import spaceTrim from 'spacetrim';
 import { $sideEffect } from '../../../../../../../src/utils/organization/$sideEffect';
-import { CodePreview } from '../../../../../../_common/components/CodePreview/CodePreview';
+import { just } from '../../../../../../../src/utils/organization/just';
 import { generateAgentMetadata } from '../generateAgentMetadata';
+import { WebsiteIntegrationTabs } from '../integration/WebsiteIntegrationTabs';
 
 export const generateMetadata = generateAgentMetadata;
 
@@ -24,20 +25,31 @@ export default async function WebsiteIntegrationAgentPage({ params }: { params:
     const { publicUrl } = await $provideServer();
     const agentUrl = `${publicUrl.href}agents/${encodeURIComponent(agentName)}`;
 
-    const code = spaceTrim(
+    const reactCode = spaceTrim(
         (block) => `
-
-            import { PromptbookAgent } from '@promptbook/components';
+            import { PromptbookAgentIntegration } from '@promptbook/components';
 
             export function YourComponent() {
                 return(
-                    <PromptbookAgent
+                    <PromptbookAgentIntegration
                         agentUrl="${agentUrl}"
                         meta={${block(JSON.stringify({ fullname, color, image, ...restMeta }, null, 4))}}
                     />
                 );
             }
-            
+        `,
+    );
+
+    // HTML Integration Code - use single quotes for meta attribute to allow JSON with double quotes inside
+    const metaJsonString = JSON.stringify({ fullname, color, image, ...restMeta }, null, 4);
+    const htmlCode = spaceTrim(
+        (block) => `
+            <script src="${publicUrl.href}api/embed.js" async defer></script>
+
+            <promptbook-agent-integration
+                agent-url="${agentUrl}"
+                meta='${block(metaJsonString)}'
+            />
         `,
     );
 
@@ -49,19 +61,24 @@ export default async function WebsiteIntegrationAgentPage({ params }: { params:
                 React application using the <code>{'<PromptbookAgent />'}</code> component.
             </p>
 
-            <CodePreview code={code} />
-            <PromptbookAgentIntegration
-                // formfactor="profile"
-                agentUrl={agentUrl}
-                meta={meta}
-                style={
-                    {
-                        // width: '400px',
-                        // height: '600px',
-                        // outline: `2px solid red`
+            <WebsiteIntegrationTabs reactCode={reactCode} htmlCode={htmlCode} />
+            {just(false) && (
+                <PromptbookAgentIntegration
+                    // formfactor="profile"
+                    agentUrl={agentUrl}
+                    meta={meta}
+                    style={
+                        {
+                            // width: '400px',
+                            // height: '600px',
+                            // outline: `2px solid red`
+                        }
                     }
-                }
-            />
+                />
+            )}
+            {htmlCode}
+            {just(true) && <div dangerouslySetInnerHTML={{ __html: htmlCode }} />}
+            {just(true) && <div dangerouslySetInnerHTML={{ __html: `<h1>Test</h1>` }} />}
         </main>
     );
 }

package/apps/agents-server/src/app/api/admin-email/route.ts

@@ -0,0 +1,12 @@
+import { getMetadata } from '../../../database/getMetadata';
+import { NextResponse } from 'next/server';
+
+export async function GET() {
+    try {
+        const adminEmail = await getMetadata('ADMIN_EMAIL');
+        return NextResponse.json({ adminEmail });
+    } catch (error) {
+        console.error('Failed to get admin email:', error);
+        return NextResponse.json({ adminEmail: 'support@ptbk.io' }, { status: 500 });
+    }
+}

package/apps/agents-server/src/app/api/agents/[agentName]/clone/route.ts

@@ -1,16 +1,15 @@
-// POST /api/agents/[agentName]/clone
 import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
-import { AgentBasicInformation } from '../../../../../../../../src/book-2.0/agent-source/AgentBasicInformation';
-import { string_book } from '../../../../../../../../src/book-2.0/agent-source/string_book';
 import { TODO_any } from '@promptbook-local/types';
 import { NextResponse } from 'next/server';
+import { string_book } from '../../../../../../../../src/book-2.0/agent-source/string_book';
 
 export async function POST(request: Request, { params }: { params: Promise<{ agentName: string }> }) {
     const { agentName } = await params;
     const collection = await $provideAgentCollectionForServer();
 
     try {
-        const source = await collection.getAgentSource(agentName);
+        const agentId = await collection.getAgentPermanentId(agentName);
+        const source = await collection.getAgentSource(agentId);
 
         // Generate new name
         // TODO: [🧠] Better naming strategy, maybe check for collisions
@@ -20,15 +19,15 @@ export async function POST(request: Request, { params }: { params: Promise<{ age
         // eslint-disable-next-line no-constant-condition
         while (true) {
             try {
-                await collection.getAgentSource(newAgentName);
-                 // If success, it means it exists, so we try next one
-                 counter++;
-                 newAgentName = `${agentName} (Copy ${counter})`;
-             } catch (error) {
-                 // If error, it likely means it does not exist (NotFoundError), so we can use it
-                 // TODO: [🧠] Check if it is really NotFoundError
-                 break;
-             }
+                await collection.getAgentPermanentId(newAgentName);
+                // If success, it means it exists, so we try next one
+                counter++;
+                newAgentName = `${agentName} (Copy ${counter})`;
+            } catch (error) {
+                // If error, it likely means it does not exist (NotFoundError), so we can use it
+                // TODO: [🧠] Check if it is really NotFoundError
+                break;
+            }
         }
 
         const lines = source.split('\n');
@@ -36,7 +35,7 @@ export async function POST(request: Request, { params }: { params: Promise<{ age
         const newSource = lines.join('\n') as string_book;
 
         const newAgent = await collection.createAgent(newSource);
-        
+
         return NextResponse.json(newAgent);
     } catch (error) {
         return NextResponse.json(

package/apps/agents-server/src/app/api/agents/[agentName]/restore/route.ts

@@ -0,0 +1,20 @@
+// POST /api/agents/[agentName]/restore - restore deleted agent
+import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
+import { TODO_any } from '@promptbook-local/types';
+import { NextResponse } from 'next/server';
+
+export async function POST(request: Request, { params }: { params: Promise<{ agentName: string }> }) {
+    const { agentName } = await params;
+    const collection = await $provideAgentCollectionForServer();
+
+    try {
+        const agentId = await collection.getAgentPermanentId(agentName);
+        await collection.restoreAgent(agentId);
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        return NextResponse.json(
+            { success: false, error: (error as TODO_any)?.message || 'Failed to restore agent' },
+            { status: 500 },
+        );
+    }
+}

package/apps/agents-server/src/app/api/agents/[agentName]/route.ts

@@ -1,14 +1,56 @@
 // DELETE /api/agents/[agentName]
+// PATCH /api/agents/[agentName] - update agent visibility
+// POST /api/agents/[agentName]/restore - restore deleted agent
+import { $getTableName } from '@/src/database/$getTableName';
+import { $provideSupabaseForServer } from '@/src/database/$provideSupabaseForServer';
 import { $provideAgentCollectionForServer } from '@/src/tools/$provideAgentCollectionForServer';
 import { TODO_any } from '@promptbook-local/types';
 import { NextResponse } from 'next/server';
 
+export async function PATCH(request: Request, { params }: { params: Promise<{ agentName: string }> }) {
+    const { agentName } = await params;
+
+    try {
+        const body = await request.json();
+        const { visibility }: { visibility: 'PUBLIC' | 'PRIVATE' } = body;
+
+        if (!visibility || !['PUBLIC', 'PRIVATE'].includes(visibility)) {
+            return NextResponse.json(
+                { success: false, error: 'Invalid visibility value. Must be PUBLIC or PRIVATE.' },
+                { status: 400 },
+            );
+        }
+
+        const supabase = $provideSupabaseForServer();
+        // const { tablePrefix } = await $provideServer();
+
+        const updateResult = await supabase
+            .from(await $getTableName(`Agent`))
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .update({ visibility } as any)
+            .or(`agentName.eq.${agentName},permanentId.eq.${agentName}`)
+            .is('deletedAt', null);
+
+        if (updateResult.error) {
+            return NextResponse.json({ success: false, error: updateResult.error.message }, { status: 500 });
+        }
+
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        return NextResponse.json(
+            { success: false, error: (error as TODO_any)?.message || 'Failed to update agent visibility' },
+            { status: 500 },
+        );
+    }
+}
+
 export async function DELETE(request: Request, { params }: { params: Promise<{ agentName: string }> }) {
     const { agentName } = await params;
     const collection = await $provideAgentCollectionForServer();
 
     try {
-        await collection.deleteAgent(agentName);
+        const agentId = await collection.getAgentPermanentId(agentName);
+        await collection.deleteAgent(agentId);
         return NextResponse.json({ success: true });
     } catch (error) {
         return NextResponse.json(

package/apps/agents-server/src/app/api/agents/route.ts

@@ -1,5 +1,7 @@
+import { $getTableName } from '@/src/database/$getTableName';
 import { $provideServer } from '@/src/tools/$provideServer';
 import { NextResponse } from 'next/server';
+import { $provideSupabaseForServer } from '../../../database/$provideSupabaseForServer';
 import { $provideAgentCollectionForServer } from '../../../tools/$provideAgentCollectionForServer';
 import { getFederatedServersFromMetadata } from '../../../utils/getFederatedServersFromMetadata';
 
@@ -8,13 +10,36 @@ export const dynamic = 'force-dynamic';
 export async function GET() {
     try {
         const collection = await $provideAgentCollectionForServer();
-        const agents = await collection.listAgents();
+        const allAgents = await collection.listAgents();
         const federatedServers = await getFederatedServersFromMetadata();
         const { publicUrl } = await $provideServer();
 
-        const agentsWithUrl = agents.map((agent) => ({
+        // Filter to only include PUBLIC agents for federated API
+        const supabase = $provideSupabaseForServer();
+        const visibilityResult = await supabase
+            .from(await $getTableName(`Agent`))
+            .select('agentName, visibility')
+            .is('deletedAt', null);
+
+        let publicAgents = allAgents;
+        if (!visibilityResult.error) {
+            const visibilityMap = new Map(
+                visibilityResult.data.map((item: { agentName: string; visibility: 'PUBLIC' | 'PRIVATE' }) => [
+                    item.agentName,
+                    item.visibility,
+                ]),
+            );
+
+            // Only include PUBLIC agents in federated API
+            publicAgents = allAgents.filter((agent) => {
+                const visibility = visibilityMap.get(agent.agentName);
+                return visibility === 'PUBLIC';
+            });
+        }
+
+        const agentsWithUrl = publicAgents.map((agent) => ({
             ...agent,
-            url: `${publicUrl.href}agents/${encodeURIComponent(agent.agentName)}`,
+            url: `${publicUrl.href}agents/${encodeURIComponent(agent.permanentId || agent.agentName)}`,
         }));
 
         const response = NextResponse.json({

package/apps/agents-server/src/app/api/api-tokens/route.ts

@@ -1,10 +1,13 @@
+import { randomUUID } from 'crypto';
+import { NextRequest, NextResponse } from 'next/server';
+import { keepUnused } from '../../../../../../src/utils/organization/keepUnused';
 import { $getTableName } from '../../../database/$getTableName';
 import { $provideSupabase } from '../../../database/$provideSupabase';
 import { isUserAdmin } from '../../../utils/isUserAdmin';
-import { randomUUID } from 'crypto';
-import { NextRequest, NextResponse } from 'next/server';
 
 export async function GET(request: NextRequest) {
+    keepUnused(request);
+
     if (!(await isUserAdmin())) {
         return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
     }
@@ -35,11 +38,7 @@ export async function POST(request: NextRequest) {
         const supabase = $provideSupabase();
         const table = await $getTableName('ApiTokens');
 
-        const { data, error } = await supabase
-            .from(table)
-            .insert({ token, note })
-            .select()
-            .single();
+        const { data, error } = await supabase.from(table).insert({ token, note }).select().single();
 
         if (error) {
             return NextResponse.json({ error: error.message }, { status: 500 });

package/apps/agents-server/src/app/api/browser-test/act/route.ts

@@ -0,0 +1,141 @@
+import { $provideBrowserForServer } from '@/src/tools/$provideBrowserForServer';
+import { NextRequest, NextResponse } from 'next/server';
+import { OpenAI } from 'openai';
+
+export const maxDuration = 60; // Allow longer timeout for agent actions
+
+export async function POST(request: NextRequest) {
+    try {
+        const { goal, action, plan } = await request.json();
+
+        if (!goal) {
+            return NextResponse.json({ error: 'Goal is required' }, { status: 400 });
+        }
+
+        const browserContext = await $provideBrowserForServer();
+        const pages = browserContext.pages();
+        let page = pages[0];
+
+        if (!page) {
+            page = await browserContext.newPage();
+            await page.goto('https://www.facebook.com/');
+        }
+
+        // Ensure we are on Facebook
+        if (!page.url().includes('facebook.com')) {
+            await page.goto('https://www.facebook.com/');
+        }
+
+        const openai = new OpenAI({
+            apiKey: process.env.OPENAI_API_KEY,
+        });
+
+        // Get page context (simplified for now: just text content)
+        // In a real scenario, we would use accessibility tree or screenshots
+        const pageText = await page.evaluate(() => document.body.innerText.slice(0, 10000)); // Limit text size
+
+        if (action === 'plan') {
+            const systemPrompt = `
+                You are an autonomous agent interacting with Facebook.
+                Your goal is to help the user achieve: "${goal}".
+                Analyze the current page content and propose a step-by-step plan.
+                Keep the plan concise and actionable.
+                Do not execute any actions yet, just list them.
+            `;
+
+            const completion = await openai.chat.completions.create({
+                model: 'gpt-4o',
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: `Current page text (truncated):\n${pageText}` },
+                ],
+            });
+
+            const plan = completion.choices[0].message.content;
+            return NextResponse.json({ plan });
+        } else if (action === 'execute') {
+            // This is a simplified execution. Ideally, this would be a loop.
+            // We ask the LLM to give us a JSON of actions to perform immediately.
+            
+            const systemPrompt = `
+                You are an autonomous agent interacting with Facebook.
+                Your goal is to help the user achieve: "${goal}".
+                ${plan ? `You have previously agreed to this plan:\n${plan}\n\n` : ''}
+                Based on the current page content, generate a list of low-level actions to perform NOW to advance the plan.
+                
+                Supported actions:
+                - { "type": "click", "selector": "css selector", "description": "reason" }
+                - { "type": "type", "selector": "css selector", "text": "text to type", "description": "reason" }
+                - { "type": "scroll", "amount": number, "description": "reason" }
+                - { "type": "wait", "ms": number, "description": "reason" }
+                - { "type": "navigate", "url": "url", "description": "reason" }
+
+                Return a JSON object with a key "actions" containing an array of these actions.
+                Example: { "actions": [{ "type": "scroll", "amount": 500, "description": "scanning feed" }, { "type": "click", "selector": "...", "description": "liking post" }] }
+                
+                IMPORTANT: Return ONLY valid JSON.
+            `;
+
+            const completion = await openai.chat.completions.create({
+                model: 'gpt-4o',
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: `Current page text (truncated):\n${pageText}` },
+                ],
+                response_format: { type: 'json_object' },
+            });
+
+            const responseContent = completion.choices[0].message.content;
+            if (!responseContent) {
+                throw new Error('No response from AI');
+            }
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const { actions } = JSON.parse(responseContent) as { actions: any[] };
+            const results = [];
+
+            for (const act of actions) {
+                console.log('Executing action:', act);
+                try {
+                    if (act.type === 'click') {
+                        // Try to find element and click
+                        // We might need to use evaluate if selector is complex or text-based, but let's stick to CSS for now
+                        // Or ask LLM to give text-based selector?
+                        // Playwright's locator is powerful.
+                        // Let's assume standard CSS selectors for now.
+                        if (act.selector) {
+                            // Try to wait for it briefly
+                            await page.waitForSelector(act.selector, { timeout: 2000 });
+                            await page.click(act.selector);
+                        }
+                    } else if (act.type === 'type') {
+                        if (act.selector && act.text) {
+                            await page.waitForSelector(act.selector, { timeout: 2000 });
+                            await page.type(act.selector, act.text);
+                        }
+                    } else if (act.type === 'scroll') {
+                        await page.evaluate((y) => window.scrollBy(0, y), act.amount || 500);
+                    } else if (act.type === 'wait') {
+                        await page.waitForTimeout(act.ms || 1000);
+                    } else if (act.type === 'navigate') {
+                        if (act.url) await page.goto(act.url);
+                    }
+                    results.push({ action: act, status: 'success' });
+                } catch (error) {
+                    console.error('Action failed:', act, error);
+                    results.push({ action: act, status: 'error', error: String(error) });
+                }
+                // Small delay between actions
+                await page.waitForTimeout(500);
+            }
+
+            return NextResponse.json({ success: true, results });
+        }
+
+        return NextResponse.json({ error: 'Invalid action' }, { status: 400 });
+
+    } catch (error) {
+        console.error('Error in Act on Facebook:', error);
+        return NextResponse.json({ error: String(error) }, { status: 500 });
+    }
+}

package/apps/agents-server/src/app/api/browser-test/screenshot/route.ts

@@ -0,0 +1,30 @@
+import { $provideBrowserForServer } from '@/src/tools/$provideBrowserForServer';
+import { serializeError } from '@promptbook-local/utils';
+import { NextResponse } from 'next/server';
+import { assertsError } from '../../../../../../../src/errors/assertsError';
+
+export async function GET() {
+    try {
+        const browserContext = await $provideBrowserForServer();
+
+        const page = await browserContext.newPage();
+
+        await page.goto('https://ptbk.io');
+        const screenshotBuffer = await page.screenshot();
+
+        // await page.close();
+        // Do not close browser
+        // <- TODO: !!!! Fix
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new NextResponse(new Blob([screenshotBuffer as any]), {
+            headers: {
+                'Content-Type': 'image/png',
+            },
+        });
+    } catch (error) {
+        assertsError(error);
+        console.error('Error taking screenshot:', error);
+        return NextResponse.json({ error: serializeError(error) }, { status: 500 });
+    }
+}

package/apps/agents-server/src/app/api/browser-test/scroll-facebook/route.ts

@@ -0,0 +1,62 @@
+import { $provideBrowserForServer } from '@/src/tools/$provideBrowserForServer';
+import { NextResponse } from 'next/server';
+import { just } from '../../../../../../../src/utils/organization/just';
+
+export const dynamic = 'force-dynamic';
+
+export async function GET() {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                console.log('Starting Facebook scroll session');
+                const browserContext = await $provideBrowserForServer();
+                const page = await browserContext.newPage();
+
+                await page.goto('https://www.facebook.com/');
+                console.log('Navigated to Facebook');
+
+                // Loop for streaming
+                while (just(true)) {
+                    // Check for login (simple check for now)
+                    // Facebook uses role="banner" for the top navigation bar when logged in
+                    const isLoggedIn = await page.$('div[role="banner"]');
+
+                    if (isLoggedIn) {
+                        // Scroll down
+                        await page.evaluate(() => window.scrollBy(0, 500));
+                        // console.log('Scrolled');
+                    } else {
+                        // console.log('Waiting for login...');
+                    }
+
+                    const buffer = await page.screenshot({ type: 'jpeg', quality: 50 });
+
+                    const boundary = '--myboundary';
+                    const header = `\r\n${boundary}\r\nContent-Type: image/jpeg\r\nContent-Length: ${buffer.length}\r\n\r\n`;
+
+                    controller.enqueue(encoder.encode(header));
+                    controller.enqueue(buffer);
+
+                    // Short delay
+                    await new Promise((r) => setTimeout(r, 200));
+                }
+            } catch (error) {
+                console.error('Stream error:', error);
+                try {
+                    controller.close();
+                } catch (e) {
+                    // Ignore error if controller is already closed
+                }
+            }
+        },
+    });
+
+    return new NextResponse(stream, {
+        headers: {
+            'Content-Type': 'multipart/x-mixed-replace; boundary=myboundary',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+        },
+    });
+}

package/apps/agents-server/src/app/api/docs/book.md/route.ts

@@ -0,0 +1,61 @@
+import { NextRequest, NextResponse } from 'next/server';
+import spaceTrim from 'spacetrim';
+import { getGroupedCommitmentDefinitions } from '../../../../../../../src/commitments';
+import { keepUnused } from '../../../../../../../src/utils/organization/keepUnused';
+
+export const dynamic = 'force-static';
+
+export async function GET(request: NextRequest) {
+    keepUnused(request);
+
+    const groupedCommitments = getGroupedCommitmentDefinitions();
+
+    const content = spaceTrim(
+        (block) => `
+            # Promptbook Documentation
+
+            Promptbook is a language for defining AI agents. It is based on Markdown and uses a set of commitments to define the behavior of the agent.
+
+            ## Commitments
+
+            The following commands (commitments) are available in Promptbook:
+
+            ${block(
+                groupedCommitments
+                    .map(({ primary, aliases }) => {
+                        const title = primary.type;
+                        const description = primary.description;
+                        const documentation = primary.documentation;
+                        const aliasList = aliases.length > 0 ? `**Aliases:** ${aliases.join(', ')}` : '';
+
+                        return spaceTrim(
+                            (block) => `
+                                ### ${title}
+
+                                ${description}
+
+                                ${aliasList}
+
+                                #### Usage
+
+                                ${block(getSafeCodeBlock(documentation))}
+                            `,
+                        );
+                    })
+                    .join('\n\n'),
+            )}
+        `,
+    );
+
+    return new NextResponse(content, {
+        headers: {
+            'Content-Type': 'text/markdown; charset=utf-8',
+        },
+    });
+}
+
+function getSafeCodeBlock(content: string, lang = 'markdown'): string {
+    const maxBackticks = Math.max(0, ...(content.match(/`+/g) || []).map((m) => m.length));
+    const fence = '`'.repeat(Math.max(3, maxBackticks + 1));
+    return `${fence}${lang}\n${content}\n${fence}`;
+}

package/apps/agents-server/src/app/api/emails/incoming/sendgrid/route.ts

@@ -0,0 +1,48 @@
+import { $getTableName } from '../../../../../database/$getTableName';
+import { $provideSupabaseForServer } from '../../../../../database/$provideSupabaseForServer';
+import { parseInboundSendgridEmail } from '../../../../../message-providers/email/sendgrid/parseInboundSendgridEmail';
+import { NextRequest, NextResponse } from 'next/server';
+
+export async function POST(request: NextRequest) {
+    try {
+        const formData = await request.formData();
+        const rawEmail = formData.get('email');
+
+        if (typeof rawEmail !== 'string') {
+            return NextResponse.json({ error: 'Missing email field' }, { status: 400 });
+        }
+
+        const email = await parseInboundSendgridEmail(rawEmail);
+
+        const supabase = await $provideSupabaseForServer();
+        const { error } = await supabase
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .from(await $getTableName('Message'))
+            .insert({
+                channel: 'EMAIL',
+                direction: 'INBOUND',
+                sender: email.sender,
+                recipients: email.recipients,
+                content: email.content,
+                metadata: {
+                    subject: email.subject,
+                    cc: email.cc,
+                    ...email.metadata,
+                },
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            } as any);
+
+        if (error) {
+            console.error('Failed to insert message', error);
+            return NextResponse.json({ error: error.message }, { status: 500 });
+        }
+
+        return NextResponse.json({ success: true });
+    } catch (error) {
+        console.error('Error processing inbound email', error);
+        return NextResponse.json(
+            { error: error instanceof Error ? error.message : 'Unknown error' },
+            { status: 500 },
+        );
+    }
+}