@promptbook/cli 0.104.0-3 → 0.104.0-5

package/apps/agents-server/src/message-providers/email/_common/utils/parseEmailAddresses.test.ts.todo

@@ -0,0 +1,117 @@
+import { describe, expect, it } from '@jest/globals';
+import { parseEmailAddresses } from './parseEmailAddresses';
+
+describe('how parseEmailAddresses works', () => {
+    it('should work with single email', () => {
+        expect(parseEmailAddresses('pavol@webgpt.cz')).toEqual([
+            {
+                fullName: null,
+                baseEmail: 'pavol@webgpt.cz',
+                fullEmail: 'pavol@webgpt.cz',
+                plus: [],
+            },
+        ]);
+    });
+
+    it('should work with simple emails', () => {
+        expect(parseEmailAddresses('pavol@webgpt.cz, jirka@webgpt.cz, tomas@webgpt.cz')).toEqual([
+            {
+                fullName: null,
+                baseEmail: 'pavol@webgpt.cz',
+                fullEmail: 'pavol@webgpt.cz',
+                plus: [],
+            },
+            {
+                fullName: null,
+                baseEmail: 'jirka@webgpt.cz',
+                fullEmail: 'jirka@webgpt.cz',
+                plus: [],
+            },
+            {
+                fullName: null,
+                baseEmail: 'tomas@webgpt.cz',
+                fullEmail: 'tomas@webgpt.cz',
+                plus: [],
+            },
+        ]);
+    });
+
+    it('should work with fullname', () => {
+        expect(
+            parseEmailAddresses(
+                'Pavol Hejný <pavol@webgpt.cz>, Jirka <jirka@webgpt.cz>, "Tomáš Studeník" <tomas@webgpt.cz>',
+            ),
+        ).toEqual([
+            {
+                fullName: 'Pavol Hejný',
+                baseEmail: 'pavol@webgpt.cz',
+                fullEmail: 'pavol@webgpt.cz',
+                plus: [],
+            },
+            {
+                fullName: 'Jirka',
+                baseEmail: 'jirka@webgpt.cz',
+                fullEmail: 'jirka@webgpt.cz',
+                plus: [],
+            },
+            {
+                fullName: 'Tomáš Studeník',
+                baseEmail: 'tomas@webgpt.cz',
+                fullEmail: 'tomas@webgpt.cz',
+                plus: [],
+            },
+        ]);
+    });
+
+    it('not confused by comma', () => {
+        expect(parseEmailAddresses(', pavol@webgpt.cz, ')).toEqual([
+            {
+                fullName: null,
+                fullEmail: 'pavol@webgpt.cz',
+                baseEmail: 'pavol@webgpt.cz',
+                plus: [],
+            },
+        ]);
+    });
+
+    it('works on real-life example', () => {
+        expect(
+            parseEmailAddresses(
+                '"bob" <bob@bot.webgpt.cz>, "pavolto" <pavol+to@ptbk.io>, "Pavol" <pavol@collboard.com>',
+            ),
+        ).toEqual([
+            {
+                fullName: 'bob',
+                fullEmail: 'bob@bot.webgpt.cz',
+                baseEmail: 'bob@bot.webgpt.cz',
+                plus: [],
+            },
+            {
+                fullName: 'pavolto',
+                fullEmail: 'pavol+to@ptbk.io',
+                baseEmail: 'pavol@ptbk.io',
+                plus: ['to'],
+            },
+            {
+                fullName: 'Pavol',
+                fullEmail: 'pavol@collboard.com',
+                baseEmail: 'pavol@collboard.com',
+                plus: [],
+            },
+        ]);
+    });
+
+    it('throws on invalid email adresses', () => {
+        expect(() => parseEmailAddresses('Pavol, Hejný')).toThrowError(/Invalid email address/);
+        expect(() => parseEmailAddresses('Pavol Hejný <>')).toThrowError(/Invalid email address/);
+        expect(() => parseEmailAddresses('Pavol Hejný, <@webgpt.cz>')).toThrowError(/Invalid email address/);
+        expect(() => parseEmailAddresses('Pavol Hejný <webgpt.cz>')).toThrowError(/Invalid email address/);
+        expect(() => parseEmailAddresses('Pavol Hejný <pavol@>')).toThrowError(/Invalid email address/);
+        expect(() => parseEmailAddresses('Pavol Hejný <a@b>,')).toThrowError(/Invalid email address/);
+    });
+});
+
+
+/**
+ * TODO: [🐫] This test fails because of aliased imports `import type { string_emails } from '@promptbook-local/types';`, fix it
+ */

package/apps/agents-server/src/message-providers/email/_common/utils/parseEmailAddresses.ts

@@ -0,0 +1,19 @@
+import type { string_emails } from '@promptbook-local/types';
+import { spaceTrim } from 'spacetrim';
+import type { EmailAddress } from '../Email';
+import { parseEmailAddress } from './parseEmailAddress';
+
+/**
+ * Parses the email addresses into its components
+ */
+export function parseEmailAddresses(value: string_emails): Array<EmailAddress> {
+    const emailAddresses = value
+        .split(',')
+        .map((email) => spaceTrim(email))
+        .filter((email) => email !== '')
+        .map((email) => parseEmailAddress(email));
+
+    // console.log('parseEmailAddresses', value, '->', emailAddresses);
+
+    return emailAddresses;
+}

package/apps/agents-server/src/message-providers/email/_common/utils/stringifyEmailAddress.test.ts.todo

@@ -0,0 +1,119 @@
+import { describe, expect, it } from '@jest/globals';
+import { stringifyEmailAddress } from './stringifyEmailAddress';
+
+describe('how stringifyEmailAddress works', () => {
+    it('should work with simple email', () => {
+        expect(
+            stringifyEmailAddress({
+                fullName: null,
+                baseEmail: 'pavol@webgpt.cz',
+                fullEmail: 'pavol@webgpt.cz',
+                plus: [],
+            }),
+        ).toBe('pavol@webgpt.cz');
+        expect(
+            stringifyEmailAddress({
+                fullName: null,
+                baseEmail: 'jirka@webgpt.cz',
+                fullEmail: 'jirka@webgpt.cz',
+                plus: [],
+            }),
+        ).toBe('jirka@webgpt.cz');
+        expect(
+            stringifyEmailAddress({
+                fullName: null,
+                baseEmail: 'tomas@webgpt.cz',
+                fullEmail: 'tomas@webgpt.cz',
+                plus: [],
+            }),
+        ).toBe('tomas@webgpt.cz');
+    });
+
+    it('should work with fullname', () => {
+        expect(
+            stringifyEmailAddress({
+                fullName: 'Pavol Hejný',
+                baseEmail: 'pavol@webgpt.cz',
+                fullEmail: 'pavol@webgpt.cz',
+                plus: [],
+            }),
+        ).toBe('"Pavol Hejný" <pavol@webgpt.cz>');
+        expect(
+            stringifyEmailAddress({
+                fullName: 'Jirka',
+                baseEmail: 'jirka@webgpt.cz',
+                fullEmail: 'jirka@webgpt.cz',
+                plus: [],
+            }),
+        ).toBe('"Jirka" <jirka@webgpt.cz>');
+        expect(
+            stringifyEmailAddress({
+                fullName: 'Tomáš Studeník',
+                baseEmail: 'tomas@webgpt.cz',
+                fullEmail: 'tomas@webgpt.cz',
+                plus: [],
+            }),
+        ).toBe('"Tomáš Studeník" <tomas@webgpt.cz>');
+    });
+
+    it('should work with plus', () => {
+        expect(
+            stringifyEmailAddress({
+                fullName: null,
+                baseEmail: 'pavol@webgpt.cz',
+                fullEmail: 'pavol+test@webgpt.cz',
+                plus: ['test'],
+            }),
+        ).toBe('pavol+test@webgpt.cz');
+        expect(
+            stringifyEmailAddress({
+                fullName: null,
+                baseEmail: 'jirka@webgpt.cz',
+                fullEmail: 'jirka+test@webgpt.cz',
+                plus: ['test'],
+            }),
+        ).toBe('jirka+test@webgpt.cz');
+        expect(
+            stringifyEmailAddress({
+                fullName: null,
+                baseEmail: 'tomas@webgpt.cz',
+                fullEmail: 'tomas+test+ainautes@webgpt.cz',
+                plus: ['test', 'ainautes'],
+            }),
+        ).toBe('tomas+test+ainautes@webgpt.cz');
+    });
+
+    it('should work with both fullname and plus', () => {
+        expect(
+            stringifyEmailAddress({
+                fullName: 'Pavol Hejný',
+                baseEmail: 'pavol@webgpt.cz',
+                fullEmail: 'pavol+test@webgpt.cz',
+                plus: ['test'],
+            }),
+        ).toBe('"Pavol Hejný" <pavol+test@webgpt.cz>');
+        expect(
+            stringifyEmailAddress({
+                fullName: 'Jirka',
+                baseEmail: 'jirka@webgpt.cz',
+                fullEmail: 'jirka+test@webgpt.cz',
+                plus: ['test'],
+            }),
+        ).toBe('"Jirka" <jirka+test@webgpt.cz>');
+        expect(
+            stringifyEmailAddress({
+                fullName: 'Tomáš Studeník',
+                baseEmail: 'tomas@webgpt.cz',
+                fullEmail: 'tomas+test+ainautes@webgpt.cz',
+                plus: ['test', 'ainautes'],
+            }),
+        ).toBe('"Tomáš Studeník" <tomas+test+ainautes@webgpt.cz>');
+    });
+
+    // TODO: [🎾] Implement and test here escaping
+});
+
+
+/**
+ * TODO: [🐫] This test fails because of aliased imports `import type { string_emails } from '@promptbook-local/types';`, fix it
+ */

package/apps/agents-server/src/message-providers/email/_common/utils/stringifyEmailAddress.ts

@@ -0,0 +1,19 @@
+import type { string_email } from '@promptbook-local/types';
+import type { EmailAddress } from '../Email';
+
+/**
+ * Makes string email from EmailAddress
+ */
+export function stringifyEmailAddress(emailAddress: EmailAddress): string_email {
+    const { fullEmail, fullName } = emailAddress;
+
+    if (fullName !== null) {
+        return `"${fullName}" <${fullEmail}>`;
+    }
+
+    return fullEmail;
+}
+
+/**
+ * TODO: [🎾] Implement and test here escaping
+ */

package/apps/agents-server/src/message-providers/email/_common/utils/stringifyEmailAddresses.test.ts.todo

@@ -0,0 +1,74 @@
+import { describe, expect, it } from '@jest/globals';
+import { stringifyEmailAddresses } from './stringifyEmailAddresses';
+
+describe('how stringifyEmailAddresses works', () => {
+    it('should work with single email', () => {
+        expect(
+            stringifyEmailAddresses([
+                {
+                    fullName: null,
+                    baseEmail: 'pavol@webgpt.cz',
+                    fullEmail: 'pavol@webgpt.cz',
+                    plus: [],
+                },
+            ]),
+        ).toEqual('pavol@webgpt.cz');
+    });
+
+    it('should work with simple emails', () => {
+        expect(
+            stringifyEmailAddresses([
+                {
+                    fullName: null,
+                    baseEmail: 'pavol@webgpt.cz',
+                    fullEmail: 'pavol@webgpt.cz',
+                    plus: [],
+                },
+                {
+                    fullName: null,
+                    baseEmail: 'jirka@webgpt.cz',
+                    fullEmail: 'jirka@webgpt.cz',
+                    plus: [],
+                },
+                {
+                    fullName: null,
+                    baseEmail: 'tomas@webgpt.cz',
+                    fullEmail: 'tomas@webgpt.cz',
+                    plus: [],
+                },
+            ]),
+        ).toEqual('pavol@webgpt.cz, jirka@webgpt.cz, tomas@webgpt.cz');
+    });
+
+    it('should work with fullname', () => {
+        expect(
+            stringifyEmailAddresses([
+                {
+                    fullName: 'Pavol Hejný',
+                    baseEmail: 'pavol@webgpt.cz',
+                    fullEmail: 'pavol@webgpt.cz',
+                    plus: [],
+                },
+                {
+                    fullName: 'Jiří Jahn',
+                    baseEmail: 'jirka@webgpt.cz',
+                    fullEmail: 'jirka@webgpt.cz',
+                    plus: [],
+                },
+                {
+                    fullName: 'Tomáš Studeník',
+                    baseEmail: 'tomas@webgpt.cz',
+                    fullEmail: 'tomas@webgpt.cz',
+                    plus: [],
+                },
+            ]),
+        ).toEqual('"Pavol Hejný" <pavol@webgpt.cz>, "Jiří Jahn" <jirka@webgpt.cz>, "Tomáš Studeník" <tomas@webgpt.cz>');
+    });
+
+    // TODO: [🎾] Implement and test here escaping
+});
+
+
+/**
+ * TODO: [🐫] This test fails because of aliased imports `import type { string_emails } from '@promptbook-local/types';`, fix it
+ */

package/apps/agents-server/src/message-providers/email/_common/utils/stringifyEmailAddresses.ts

@@ -0,0 +1,14 @@
+import type { string_emails } from '@promptbook-local/types';
+import type { EmailAddress } from '../Email';
+import { stringifyEmailAddress } from './stringifyEmailAddress';
+
+/**
+ * Makes string email from multiple EmailAddress
+ */
+export function stringifyEmailAddresses(emailAddresses: Array<EmailAddress>): string_emails {
+    return emailAddresses.map((emailAddress) => stringifyEmailAddress(emailAddress)).join(', ');
+}
+
+/**
+ * TODO: [🎾] Implement and test here escaping
+ */

package/apps/agents-server/src/message-providers/email/sendgrid/SendgridMessageProvider.ts

@@ -0,0 +1,44 @@
+import { removeMarkdownFormatting } from '@promptbook-local/markdown-utils';
+import type { really_any } from '@promptbook-local/types';
+import sendgridEmailClient from '@sendgrid/mail';
+import { marked } from 'marked';
+import { MessageProvider } from '../../interfaces/MessageProvider';
+import { OutboundEmail } from '../_common/Email';
+import { parseEmailAddress } from '../_common/utils/parseEmailAddress';
+
+export class SendgridMessageProvider implements MessageProvider {
+    constructor(private readonly apiKey: string) {
+        sendgridEmailClient.setApiKey(this.apiKey);
+    }
+
+    public async send(message: OutboundEmail): Promise<really_any> {
+        const sender = message.sender;
+        const recipients = (Array.isArray(message.recipients) ? message.recipients : [message.recipients]).filter(
+            Boolean,
+        ) as really_any[];
+
+        const text = removeMarkdownFormatting(message.content);
+        const html = await marked.parse(message.content);
+
+        const { fullEmail, fullName } = parseEmailAddress(sender);
+
+        const response = await sendgridEmailClient.send({
+            from: {
+                email: fullEmail,
+                name: fullName || undefined,
+            },
+            to: recipients.map((r) => {
+                const { fullEmail, fullName } = parseEmailAddress(r.email || r.baseEmail || r);
+                return {
+                    email: fullEmail,
+                    name: r.name || fullName || undefined,
+                };
+            }),
+            subject: message.metadata?.subject || 'No Subject',
+            text,
+            html,
+        });
+
+        return response;
+    }
+}

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

@@ -0,0 +1,51 @@
+import { removeMarkdownFormatting } from '@promptbook-local/markdown-utils';
+import type { really_any } from '@promptbook-local/types';
+import { marked } from 'marked';
+// @ts-expect-error: Zeptomail types are not resolving correctly
+import { SendMailClient } from 'zeptomail';
+import { MessageProvider } from '../../interfaces/MessageProvider';
+import { OutboundEmail } from '../_common/Email';
+
+export class ZeptomailMessageProvider implements MessageProvider {
+    constructor(private readonly apiKey: string) {}
+
+    public async send(message: OutboundEmail): Promise<really_any> {
+        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 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,
+                    },
+                })),
+                subject: message.metadata?.subject || 'No Subject',
+                textbody,
+                htmlbody,
+                track_clicks: true,
+                track_opens: true,
+            });
+
+            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/message-providers/index.ts

@@ -0,0 +1,13 @@
+import { SendgridMessageProvider } from './email/sendgrid/SendgridMessageProvider';
+import { ZeptomailMessageProvider } from './email/zeptomail/ZeptomailMessageProvider';
+import { MessageProvider } from './interfaces/MessageProvider';
+
+export const EMAIL_PROVIDERS: Record<string, MessageProvider> = {};
+
+if (process.env.ZEPTOMAIL_API_KEY) {
+    EMAIL_PROVIDERS['ZEPTOMAIL'] = new ZeptomailMessageProvider(process.env.ZEPTOMAIL_API_KEY);
+}
+
+if (process.env.SENDGRID_API_KEY) {
+    EMAIL_PROVIDERS['SENDGRID'] = new SendgridMessageProvider(process.env.SENDGRID_API_KEY);
+}

package/apps/agents-server/src/message-providers/interfaces/MessageProvider.ts

@@ -0,0 +1,11 @@
+import type { Message, really_any, string_email } from '@promptbook-local/types';
+
+export type MessageProvider = {
+    /**
+     * Sends a message through the provider
+     *
+     * @param message The message to send
+     * @returns Raw response from the provider
+     */
+    send(message: Message<string_email>): Promise<really_any>;
+};

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

@@ -0,0 +1,91 @@
+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';
+import { OutboundEmail } from '../../message-providers/email/_common/Email';
+
+/**
+ * Sends a message
+ */
+export async function sendMessage(message: OutboundEmail): Promise<void> {
+    const supabase = await $provideSupabaseForServer();
+
+    // 1. Insert message
+    const { data: insertedMessage, error: insertError } = await supabase
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .from(await $getTableName('Message'))
+        .insert({
+            channel: message.channel || 'UNKNOWN',
+            direction: message.direction || 'OUTBOUND',
+            sender: message.sender,
+            recipients: message.recipients,
+            content: message.content,
+            threadId: message.threadId,
+            metadata: message.metadata,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        } as any)
+        .select()
+        .single();
+
+    if (insertError) {
+        throw new Error(`Failed to insert message: ${insertError.message}`);
+    }
+
+    if (!insertedMessage) {
+        throw new Error('Failed to insert message: No data returned');
+    }
+
+    // 2. If outbound and email, try to send
+    if (message.direction === 'OUTBOUND' && message.channel === 'EMAIL') {
+        const providers = Object.keys(EMAIL_PROVIDERS);
+
+        if (providers.length === 0) {
+            console.warn('No email providers configured');
+            return;
+        }
+
+        let isSent = false;
+
+        for (const providerName of providers) {
+            const provider = EMAIL_PROVIDERS[providerName];
+            let isSuccessful = false;
+            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: serializeError(error) };
+            }
+
+            // 3. Log attempt
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await supabase.from(await $getTableName('MessageSendAttempt')).insert({
+                // @ts-expect-error: insertedMessage is any
+                messageId: insertedMessage.id,
+                providerName,
+                isSuccessful,
+                raw,
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            } as any);
+
+            if (isSuccessful) {
+                break;
+            }
+        }
+
+        if (!isSent) {
+            throw new Error('Failed to send email via any provider');
+        }
+    }
+}
+
+/**
+ * TODO: !!!! Move to `message-providers` and rename `message-providers` -> `messages`
+ */

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