@promptbook/cli 0.104.0-4 → 0.104.0-6

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/sendgrid/parseInboundSendgridEmail.ts

@@ -0,0 +1,49 @@
+import { string_markdown } from '@promptbook-local/types';
+import { simpleParser } from 'mailparser';
+import TurndownService from 'turndown';
+import { extractBodyContentFromHtml } from '../../../utils/content/extractBodyContentFromHtml';
+import type { InboundEmail } from '../_common/Email';
+import { parseEmailAddress } from '../_common/utils/parseEmailAddress';
+import { parseEmailAddresses } from '../_common/utils/parseEmailAddresses';
+
+/**
+ * Function parseInboundSendgridEmail will parse raw inbound email from Sendgrid and return Email object
+ */
+export async function parseInboundSendgridEmail(rawEmail: string): Promise<InboundEmail> {
+    const parsedEmail = await simpleParser(rawEmail);
+
+    const toArray = !Array.isArray(parsedEmail.to)
+        ? parsedEmail.to === undefined
+            ? []
+            : [parsedEmail.to]
+        : parsedEmail.to;
+    const to = toArray.flatMap((_) => parseEmailAddresses(_.text));
+
+    const ccArray = !Array.isArray(parsedEmail.cc)
+        ? parsedEmail.cc === undefined
+            ? []
+            : [parsedEmail.cc]
+        : parsedEmail.cc;
+    const cc = ccArray.flatMap((_) => parseEmailAddresses(_.text));
+
+    const turndownService = new TurndownService();
+
+    const content = (parsedEmail.html
+        ? turndownService.turndown(extractBodyContentFromHtml(parsedEmail.html))
+        : parsedEmail.text || '') as string_markdown;
+
+    const email: InboundEmail = {
+        channel: 'EMAIL',
+        direction: 'INBOUND',
+        sender: parseEmailAddress(parsedEmail.from?.text || '').fullEmail,
+        recipients: to.map((_) => _.fullEmail),
+        cc,
+        subject: parsedEmail.subject || '',
+        content,
+        attachments: [
+            /* <- TODO: [📯] Parse attachments */
+        ],
+    };
+
+    return email;
+}

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/content/extractBodyContentFromHtml.ts

@@ -0,0 +1,19 @@
+import type { string_html } from '@promptbook-local/types';
+
+/**
+ * Extract the first heading from HTML
+ *
+ * @param contentText HTML
+ * @returns heading
+ */
+export function extractBodyContentFromHtml(html: string_html): string_html {
+    // Note: Not using DOMParser, because it's overkill for this simple task
+
+    const match = html.match(/<body[^>]*>(?<bodyContent>[\s\S]*)<\/body>/s);
+
+    if (!match) {
+        return html;
+    }
+
+    return match.groups!.bodyContent!;
+}

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;
+}