@promptbook/cli 0.104.0-2 → 0.104.0-4

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

@@ -0,0 +1,73 @@
+import type { Message, string_email, string_person_fullname } from '@promptbook-local/types';
+
+/**
+ * Single email which was received by the application
+ */
+export type InboundEmail = Email & { direction: 'INBOUND' };
+
+/**
+ * Single email which was sended from the application
+ */
+export type OutboundEmail = Email & { direction: 'OUTBOUND' };
+
+/**
+ * Single email
+ */
+type Email = Message<string_email> & {
+    /**
+     * Channel of the message
+     *
+     * @default 'EMAIL'
+     */
+    readonly channel?: 'EMAIL';
+
+    /**
+     * Carbon copy email addresses
+     *
+     * Note: Not working with BCC (Blind Carbon Copy) because we want to have all emails in the same thread
+     *       and for hidden emails we can just call $sendEmail multiple times
+     */
+    readonly cc: Array<EmailAddress>;
+
+    /**
+     * Email subject
+     */
+    readonly subject: string;
+
+    /**
+     * Email attachments
+     */
+    readonly attachments: Array<File>;
+};
+
+export type EmailAddress = {
+    /**
+     * Everything outside of `<>` in email address
+     *
+     * @example "Pavol Hejný <pavol@hejny.cz>" -> "Pavol Hejný"
+     * @example "\"Pavol Hejný\" <pavol@hejny.cz>" -> "Pavol Hejný"
+     */
+    fullName: string_person_fullname | string | null;
+
+    /**
+     * Everything after `+` in email address
+     *
+     * @example "pavol+spam@webgpt.cz" -> ["spam"]
+     * @example "pavol+spam+debug@webgpt.cz" -> ["spam","debug"]
+     */
+    plus: Array<string>;
+
+    /**
+     * Pure email address
+     *
+     * @example "pavol@webgpt.cz"
+     */
+    baseEmail: string_email;
+
+    /**
+     * Full email address without the name but with +
+     *
+     * @example "pavol+test@webgpt.cz"
+     */
+    fullEmail: string_email;
+};

package/apps/agents-server/src/message-providers/email/_common/utils/TODO.txt

@@ -0,0 +1 @@
+TODO: [🧠][🏰] Maybe move all of theese functions into `@promptbook/utils`

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

@@ -0,0 +1,108 @@
+import { describe, expect, it } from '@jest/globals';
+import { parseEmailAddress } from './parseEmailAddress';
+
+describe('how parseEmailAddress works', () => {
+    it('should work with simple email', () => {
+        expect(parseEmailAddress('pavol@webgpt.cz')).toEqual({
+            fullName: null,
+            baseEmail: 'pavol@webgpt.cz',
+            fullEmail: 'pavol@webgpt.cz',
+            plus: [],
+        });
+        expect(parseEmailAddress('jirka@webgpt.cz')).toEqual({
+            fullName: null,
+            baseEmail: 'jirka@webgpt.cz',
+            fullEmail: 'jirka@webgpt.cz',
+            plus: [],
+        });
+        expect(parseEmailAddress('tomas@webgpt.cz')).toEqual({
+            fullName: null,
+            baseEmail: 'tomas@webgpt.cz',
+            fullEmail: 'tomas@webgpt.cz',
+            plus: [],
+        });
+    });
+
+    it('should work with fullname', () => {
+        expect(parseEmailAddress('Pavol Hejný <pavol@webgpt.cz>')).toEqual({
+            fullName: 'Pavol Hejný',
+            baseEmail: 'pavol@webgpt.cz',
+            fullEmail: 'pavol@webgpt.cz',
+            plus: [],
+        });
+        expect(parseEmailAddress('Jirka <jirka@webgpt.cz>')).toEqual({
+            fullName: 'Jirka',
+            baseEmail: 'jirka@webgpt.cz',
+            fullEmail: 'jirka@webgpt.cz',
+            plus: [],
+        });
+        expect(parseEmailAddress('"Tomáš Studeník" <tomas@webgpt.cz>')).toEqual({
+            fullName: 'Tomáš Studeník',
+            baseEmail: 'tomas@webgpt.cz',
+            fullEmail: 'tomas@webgpt.cz',
+            plus: [],
+        });
+    });
+
+    it('should work with plus', () => {
+        expect(parseEmailAddress('pavol+test@webgpt.cz')).toEqual({
+            fullName: null,
+            baseEmail: 'pavol@webgpt.cz',
+            fullEmail: 'pavol+test@webgpt.cz',
+            plus: ['test'],
+        });
+        expect(parseEmailAddress('jirka+test@webgpt.cz')).toEqual({
+            fullName: null,
+            baseEmail: 'jirka@webgpt.cz',
+            fullEmail: 'jirka+test@webgpt.cz',
+            plus: ['test'],
+        });
+        expect(parseEmailAddress('tomas+test+ainautes@webgpt.cz')).toEqual({
+            fullName: null,
+            baseEmail: 'tomas@webgpt.cz',
+            fullEmail: 'tomas+test+ainautes@webgpt.cz',
+            plus: ['test', 'ainautes'],
+        });
+    });
+
+    it('should work with both fullname and plus', () => {
+        expect(parseEmailAddress('Pavol Hejný <pavol+foo@webgpt.cz>')).toEqual({
+            fullName: 'Pavol Hejný',
+            baseEmail: 'pavol@webgpt.cz',
+            fullEmail: 'pavol+foo@webgpt.cz',
+            plus: ['foo'],
+        });
+        expect(parseEmailAddress('Jirka <jirka+test@webgpt.cz>')).toEqual({
+            fullName: 'Jirka',
+            baseEmail: 'jirka@webgpt.cz',
+            fullEmail: 'jirka+test@webgpt.cz',
+            plus: ['test'],
+        });
+        expect(parseEmailAddress('"Tomáš Studeník" <tomas+test+ainautes@webgpt.cz>')).toEqual({
+            fullName: 'Tomáš Studeník',
+            baseEmail: 'tomas@webgpt.cz',
+            fullEmail: 'tomas+test+ainautes@webgpt.cz',
+            plus: ['test', 'ainautes'],
+        });
+    });
+
+    it('throws on multiple adresses', () => {
+        expect(() => parseEmailAddress('Pavol <pavol@webgpt.cz>, Jirka <jirka@webgpt.cz>')).toThrowError(
+            /Seems like you are trying to parse multiple email addresses/,
+        );
+    });
+
+    it('throws on invalid email adresses', () => {
+        expect(() => parseEmailAddress('')).toThrowError(/Invalid email address/);
+        expect(() => parseEmailAddress('Pavol Hejný')).toThrowError(/Invalid email address/);
+        expect(() => parseEmailAddress('Pavol Hejný <>')).toThrowError(/Invalid email address/);
+        expect(() => parseEmailAddress('Pavol Hejný <@webgpt.cz>')).toThrowError(/Invalid email address/);
+        expect(() => parseEmailAddress('Pavol Hejný <webgpt.cz>')).toThrowError(/Invalid email address/);
+        expect(() => parseEmailAddress('Pavol Hejný <pavol@>')).toThrowError(/Invalid email address/);
+        expect(() => parseEmailAddress('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/parseEmailAddress.ts

@@ -0,0 +1,62 @@
+import type { string_email } from '@promptbook-local/types';
+import { isValidEmail, spaceTrim } from '@promptbook-local/utils';
+import { EmailAddress } from '../Email';
+
+/**
+ * Parses the email address into its components
+ */
+export function parseEmailAddress(value: string_email): EmailAddress {
+    if (value.includes(',')) {
+        throw new Error('Seems like you are trying to parse multiple email addresses, use parseEmailAddresses instead');
+    }
+
+    let fullName = value.match(/^(?:"?([^"]+)"?|[^<]+)\s*</)?.[1] ?? null;
+
+    if (fullName !== null) {
+        fullName = fullName.trim();
+    }
+
+    const fullEmail = value.match(/<([^>]+)>/)?.[1] ?? value;
+    const plus: Array<string> = [];
+
+    if (!isValidEmail(fullEmail)) {
+        throw new Error(
+            spaceTrim(
+                (block) => `
+                    Invalid email address "${fullEmail}"
+
+                    Parsed:
+                    ${block(JSON.stringify({ fullName, fullEmail, plus }, null, 4))}
+                
+                `,
+            ),
+        );
+    }
+
+    if (fullEmail.includes('+')) {
+        const [user, domain] = fullEmail.split('@');
+
+        if (!user || !domain) {
+            throw new Error('Can not parse email address');
+            //               <- TODO: ShouldNeverHappenError
+        }
+
+        const userParts = user.split('+');
+        userParts.shift();
+
+        plus.push(...userParts);
+    }
+
+    let baseEmail = fullEmail;
+
+    for (const plusItem of plus) {
+        baseEmail = baseEmail.replace(`+${plusItem}`, '');
+    }
+
+    return {
+        fullName,
+        baseEmail,
+        fullEmail,
+        plus,
+    };
+}

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