@promptbook/cli 0.104.0-4 → 0.104.0-5

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

@@ -0,0 +1,102 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { $getTableName } from '../../../database/$getTableName';
+import { $provideSupabase } from '../../../database/$provideSupabase';
+import { isUserAdmin } from '../../../utils/isUserAdmin';
+
+const DEFAULT_PAGE_SIZE = 20;
+const MAX_PAGE_SIZE = 100;
+
+function parsePositiveInt(value: string | null, fallback: number): number {
+    if (!value) return fallback;
+    const parsed = parseInt(value, 10);
+    if (Number.isNaN(parsed) || parsed <= 0) return fallback;
+    return parsed;
+}
+
+/**
+ * List messages with filters, search and pagination.
+ */
+export async function GET(request: NextRequest) {
+    if (!(await isUserAdmin())) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    try {
+        const searchParams = request.nextUrl.searchParams;
+
+        const page = parsePositiveInt(searchParams.get('page'), 1);
+        const pageSize = Math.min(MAX_PAGE_SIZE, parsePositiveInt(searchParams.get('pageSize'), DEFAULT_PAGE_SIZE));
+        const search = searchParams.get('search')?.trim() || '';
+        const channel = searchParams.get('channel');
+        const direction = searchParams.get('direction');
+
+        const supabase = $provideSupabase();
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let query = supabase.from(await $getTableName('Message')).select('*', { count: 'exact' });
+
+        if (channel) {
+            query = query.eq('channel', channel);
+        }
+
+        if (direction) {
+            query = query.eq('direction', direction);
+        }
+
+        if (search) {
+            // Search in content, subject (if in metadata?), sender/recipient emails
+            // Note: sender and recipients are JSONB, so ilike might not work directly on them unless cast to text
+            // Content is TEXT.
+            const escaped = search.replace(/%/g, '\\%').replace(/_/g, '\\_');
+            // Assuming simple search on content for now to avoid complexity with JSONB search in generic supabase client
+            query = query.ilike('content', `%${escaped}%`);
+        }
+
+        // Default sort by createdAt desc
+        query = query.order('createdAt', { ascending: false });
+
+        const from = (page - 1) * pageSize;
+        const to = from + pageSize - 1;
+
+        query = query.range(from, to);
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const { data: messages, error, count } = (await query) as { data: any[]; error: any; count: number };
+
+        if (error) {
+            console.error('List messages error:', error);
+            return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+        }
+
+        // Fetch attempts for these messages
+        if (messages && messages.length > 0) {
+            const messageIds = messages.map((m) => m.id);
+            const { data: attempts, error: attemptsError } = await supabase
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                .from(await $getTableName('MessageSendAttempt'))
+                .select('*')
+                .in('messageId', messageIds);
+
+            if (attemptsError) {
+                console.error('Fetch message attempts error:', attemptsError);
+                // We don't fail the whole request, just log it.
+            } else {
+                // Attach attempts to messages
+                for (const message of messages) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    (message as any).sendAttempts = attempts?.filter((a: any) => a.messageId === message.id) || [];
+                }
+            }
+        }
+
+        return NextResponse.json({
+            items: messages ?? [],
+            total: count ?? 0,
+            page,
+            pageSize,
+        });
+    } catch (error) {
+        console.error('List messages error:', error);
+        return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+    }
+}

package/apps/agents-server/src/components/Header/Header.tsx

@@ -297,6 +297,10 @@ export function Header(props: HeaderProps) {
                               label: 'Chat history',
                               href: '/admin/chat-history',
                           },
+                          {
+                              label: 'Messages & Emails',
+                              href: '/admin/messages',
+                          },
                           {
                               label: 'Chat feedback',
                               href: '/admin/chat-feedback',

package/apps/agents-server/src/database/$provideSupabaseForBrowser.ts

@@ -1,6 +1,6 @@
-import { AgentsDatabaseSchema } from '@promptbook-local/types';
 import { $isRunningInBrowser } from '@promptbook-local/utils';
 import { createClient, SupabaseClient } from '@supabase/supabase-js';
+import { AgentsServerDatabase } from './schema';
 
 /**
  * Internal cache for `$provideSupabaseForBrowser`
@@ -8,7 +8,7 @@ import { createClient, SupabaseClient } from '@supabase/supabase-js';
  * @private
  * @singleton
  */
-let supabase: SupabaseClient<AgentsDatabaseSchema>;
+let supabase: SupabaseClient<AgentsServerDatabase>;
 
 /**
  * Get supabase client
@@ -27,7 +27,7 @@ export function $provideSupabaseForBrowser(): typeof supabase {
 
     if (!supabase) {
         // Create a single supabase client for interacting with your database
-        supabase = createClient<AgentsDatabaseSchema>(
+        supabase = createClient<AgentsServerDatabase>(
             process.env.NEXT_PUBLIC_SUPABASE_URL!,
             process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
         );

package/apps/agents-server/src/database/$provideSupabaseForServer.ts

@@ -18,7 +18,7 @@ let supabase: SupabaseClient<AgentsServerDatabase>;
  *
  * @returns instance of supabase client
  */
-export function $provideSupabaseForServer(): typeof supabase {
+export function $provideSupabaseForServer(): SupabaseClient<AgentsServerDatabase> {
     if (!$isRunningInNode()) {
         throw new Error(
             'Function `$provideSupabaseForServer` can not be used in browser, use `$provideSupabaseForBrowser` instead.',

package/apps/agents-server/src/database/$provideSupabaseForWorker.ts

@@ -1,6 +1,6 @@
-import { AgentsDatabaseSchema } from '@promptbook-local/types';
 import { $isRunningInWebWorker } from '@promptbook-local/utils';
 import { createClient, SupabaseClient } from '@supabase/supabase-js';
+import { AgentsServerDatabase } from './schema';
 
 /**
  * Internal cache for `$provideSupabaseForWorker`
@@ -8,7 +8,7 @@ import { createClient, SupabaseClient } from '@supabase/supabase-js';
  * @private
  * @singleton
  */
-let supabase: SupabaseClient<AgentsDatabaseSchema>;
+let supabase: SupabaseClient<AgentsServerDatabase>;
 
 /**
  * Get supabase client
@@ -27,7 +27,7 @@ export function $provideSupabaseForWorker(): typeof supabase {
 
     if (!supabase) {
         // Create a single supabase client for interacting with your database
-        supabase = createClient<AgentsDatabaseSchema>(
+        supabase = createClient<AgentsServerDatabase>(
             process.env.NEXT_PUBLIC_SUPABASE_URL!,
             process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
         );

package/apps/agents-server/src/database/migrations/2025-11-0001-initial-schema.sql

@@ -1,6 +1,4 @@
--- Note: This is primary source of truth for the database schema
---       In future we want to be compatible with more then Supabase so we keep SQL as main schema definition
---       To update, search for [💽]
+
 
 
 CREATE TABLE IF NOT EXISTS "prefix_Agent" (

package/apps/agents-server/src/database/migrations/2025-11-0002-metadata-table.sql

@@ -1,6 +1,4 @@
--- Note: This is primary source of truth for the database schema
---       In future we want to be compatible with more then Supabase so we keep SQL as main schema definition
---       To update, search for [💽]
+
 
 
 CREATE TABLE IF NOT EXISTS "prefix_Metadata" (

package/apps/agents-server/src/database/schema.ts

@@ -3,7 +3,7 @@
  * Source of truth: `schema.sql` *(do not edit table structure here manually)*
  *
  * [💽] Prompt:
- * Re-generate supabase typescript schema from the `./schema.sql`
+ * Re-generate supabase typescript schema from `./migrations/*.sql`
  */
 
 // Json helper (Supabase style)
@@ -120,7 +120,14 @@ export type AgentsServerDatabase = {
                     agentSource?: string;
                     promptbookEngineVersion?: string;
                 };
-                Relationships: [];
+                Relationships: [
+                    {
+                        foreignKeyName: 'AgentHistory_agentName_fkey';
+                        columns: ['agentName'];
+                        referencedRelation: 'Agent';
+                        referencedColumns: ['agentName'];
+                    },
+                ];
             };
             ChatHistory: {
                 Row: {
@@ -174,7 +181,14 @@ export type AgentsServerDatabase = {
                     source?: 'AGENT_PAGE_CHAT' | 'OPENAI_API_COMPATIBILITY' | null;
                     apiKey?: string | null;
                 };
-                Relationships: [];
+                Relationships: [
+                    {
+                        foreignKeyName: 'ChatHistory_agentName_fkey';
+                        columns: ['agentName'];
+                        referencedRelation: 'Agent';
+                        referencedColumns: ['agentName'];
+                    },
+                ];
             };
             ChatFeedback: {
                 Row: {
@@ -228,7 +242,14 @@ export type AgentsServerDatabase = {
                     language?: string | null;
                     platform?: string | null;
                 };
-                Relationships: [];
+                Relationships: [
+                    {
+                        foreignKeyName: 'ChatFeedback_agentName_fkey';
+                        columns: ['agentName'];
+                        referencedRelation: 'Agent';
+                        referencedColumns: ['agentName'];
+                    },
+                ];
             };
             User: {
                 Row: {
@@ -408,6 +429,76 @@ export type AgentsServerDatabase = {
                     },
                 ];
             };
+            Message: {
+                Row: {
+                    id: number;
+                    createdAt: string;
+                    channel: string;
+                    direction: string;
+                    sender: Json;
+                    recipients: Json | null;
+                    content: string;
+                    threadId: string | null;
+                    metadata: Json | null;
+                };
+                Insert: {
+                    id?: number;
+                    createdAt?: string;
+                    channel: string;
+                    direction: string;
+                    sender: Json;
+                    recipients?: Json | null;
+                    content: string;
+                    threadId?: string | null;
+                    metadata?: Json | null;
+                };
+                Update: {
+                    id?: number;
+                    createdAt?: string;
+                    channel?: string;
+                    direction?: string;
+                    sender?: Json;
+                    recipients?: Json | null;
+                    content?: string;
+                    threadId?: string | null;
+                    metadata?: Json | null;
+                };
+                Relationships: [];
+            };
+            MessageSendAttempt: {
+                Row: {
+                    id: number;
+                    createdAt: string;
+                    messageId: number;
+                    providerName: string;
+                    isSuccessful: boolean;
+                    raw: Json | null;
+                };
+                Insert: {
+                    id?: number;
+                    createdAt?: string;
+                    messageId: number;
+                    providerName: string;
+                    isSuccessful: boolean;
+                    raw?: Json | null;
+                };
+                Update: {
+                    id?: number;
+                    createdAt?: string;
+                    messageId?: number;
+                    providerName?: string;
+                    isSuccessful?: boolean;
+                    raw?: Json | null;
+                };
+                Relationships: [
+                    {
+                        foreignKeyName: 'MessageSendAttempt_messageId_fkey';
+                        columns: ['messageId'];
+                        referencedRelation: 'Message';
+                        referencedColumns: ['id'];
+                    },
+                ];
+            };
         };
         Views: Record<string, never>;
         Functions: Record<string, never>;

package/apps/agents-server/src/message-providers/email/zeptomail/ZeptomailMessageProvider.ts

@@ -10,34 +10,42 @@ export class ZeptomailMessageProvider implements MessageProvider {
     constructor(private readonly apiKey: string) {}
 
     public async send(message: OutboundEmail): Promise<really_any> {
-        const client = new SendMailClient({ url: 'api.zeptomail.com/', token: this.apiKey });
+        try {
+            const client = new SendMailClient({ url: 'api.zeptomail.com/', token: this.apiKey });
 
-        const sender = message.sender as really_any;
-        const recipients = (Array.isArray(message.recipients) ? message.recipients : [message.recipients]).filter(
-            Boolean,
-        ) as really_any[];
+            const sender = message.sender as really_any;
+            const recipients = (Array.isArray(message.recipients) ? message.recipients : [message.recipients]).filter(
+                Boolean,
+            ) as really_any[];
 
-        const textbody = removeMarkdownFormatting(message.content);
-        const htmlbody = await marked.parse(message.content);
+            const textbody = removeMarkdownFormatting(message.content);
+            const htmlbody = await marked.parse(message.content);
 
-        const response = await client.sendMail({
-            from: {
-                address: sender.email || sender.baseEmail || sender,
-                name: sender.name || sender.fullName || undefined,
-            },
-            to: recipients.map((r) => ({
-                email_address: {
-                    address: r.email || r.baseEmail || r,
-                    name: r.name || r.fullName || undefined,
+            const response = await client.sendMail({
+                from: {
+                    address: sender.email || sender.baseEmail || sender,
+                    name: sender.name || sender.fullName || undefined,
                 },
-            })),
-            subject: message.metadata?.subject || 'No Subject',
-            textbody,
-            htmlbody,
-            track_clicks: true,
-            track_opens: true,
-        });
+                to: recipients.map((r) => ({
+                    email_address: {
+                        address: r.email || r.baseEmail || r,
+                        name: r.name || r.fullName || undefined,
+                    },
+                })),
+                subject: message.metadata?.subject || 'No Subject',
+                textbody,
+                htmlbody,
+                track_clicks: true,
+                track_opens: true,
+            });
 
-        return response;
+            return response;
+        } catch (raw: really_any) {
+            if (!('error' in raw)) {
+                throw raw;
+            }
+
+            throw new Error(raw.error.message, raw.error.details);
+        }
     }
 }

package/apps/agents-server/src/utils/messages/sendMessage.ts

@@ -1,4 +1,6 @@
 import type { really_any } from '@promptbook-local/types';
+import { serializeError } from '@promptbook-local/utils';
+import { assertsError } from '../../../../../src/errors/assertsError';
 import { $getTableName } from '../../database/$getTableName';
 import { $provideSupabaseForServer } from '../../database/$provideSupabaseForServer';
 import { EMAIL_PROVIDERS } from '../../message-providers';
@@ -9,15 +11,11 @@ import { OutboundEmail } from '../../message-providers/email/_common/Email';
  */
 export async function sendMessage(message: OutboundEmail): Promise<void> {
     const supabase = await $provideSupabaseForServer();
-    // @ts-expect-error: Tables are not yet in types
-    const messageTable = await $getTableName('Message');
-    // @ts-expect-error: Tables are not yet in types
-    const messageSendAttemptTable = await $getTableName('MessageSendAttempt');
 
     // 1. Insert message
     const { data: insertedMessage, error: insertError } = await supabase
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        .from(messageTable as any)
+        .from(await $getTableName('Message'))
         .insert({
             channel: message.channel || 'UNKNOWN',
             direction: message.direction || 'OUTBOUND',
@@ -56,17 +54,19 @@ export async function sendMessage(message: OutboundEmail): Promise<void> {
             let raw: really_any = null;
 
             try {
+                console.log(`📤 Sending email via ${providerName}`);
                 raw = await provider.send(message);
                 isSuccessful = true;
                 isSent = true;
             } catch (error) {
+                assertsError(error);
                 console.error(`Failed to send email via ${providerName}`, error);
-                raw = { error: error instanceof Error ? error.message : String(error) };
+                raw = { error: serializeError(error) };
             }
 
             // 3. Log attempt
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            await supabase.from(messageSendAttemptTable as any).insert({
+            await supabase.from(await $getTableName('MessageSendAttempt')).insert({
                 // @ts-expect-error: insertedMessage is any
                 messageId: insertedMessage.id,
                 providerName,

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

@@ -0,0 +1,72 @@
+import type { Json } from '../database/schema';
+
+export type MessageRow = {
+    id: number;
+    createdAt: string;
+    channel: string;
+    direction: string;
+    sender: Json;
+    recipients: Json;
+    content: string;
+    threadId: string | null;
+    metadata: Json;
+    // Joined fields
+    sendAttempts?: MessageSendAttemptRow[];
+};
+
+export type MessageSendAttemptRow = {
+    id: number;
+    createdAt: string;
+    messageId: number;
+    providerName: string;
+    isSuccessful: boolean;
+    raw: Json;
+};
+
+export type MessagesListResponse = {
+    items: MessageRow[];
+    total: number;
+    page: number;
+    pageSize: number;
+};
+
+export type MessagesListParams = {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    channel?: string;
+    direction?: string;
+};
+
+/**
+ * Build query string for messages listing.
+ */
+function buildQuery(params: MessagesListParams): string {
+    const searchParams = new URLSearchParams();
+
+    if (params.page && params.page > 0) searchParams.set('page', String(params.page));
+    if (params.pageSize && params.pageSize > 0) searchParams.set('pageSize', String(params.pageSize));
+    if (params.search) searchParams.set('search', params.search);
+    if (params.channel) searchParams.set('channel', params.channel);
+    if (params.direction) searchParams.set('direction', params.direction);
+
+    const qs = searchParams.toString();
+    return qs ? `?${qs}` : '';
+}
+
+/**
+ * Fetch messages from the admin API.
+ */
+export async function $fetchMessages(params: MessagesListParams = {}): Promise<MessagesListResponse> {
+    const qs = buildQuery(params);
+    const response = await fetch(`/api/messages${qs}`, {
+        method: 'GET',
+    });
+
+    if (!response.ok) {
+        const data = await response.json().catch(() => ({}));
+        throw new Error(data.error || 'Failed to load messages');
+    }
+
+    return (await response.json()) as MessagesListResponse;
+}