@lovelybunch/api 1.0.75-alpha.9 → 1.0.75

package/dist/routes/api/v1/mail/route.d.ts

@@ -0,0 +1,294 @@
+import { Context } from 'hono';
+import type { MailFolder } from '@lovelybunch/types';
+/**
+ * GET /api/v1/mail/:folder
+ * List emails in a folder
+ */
+export declare function listMailHandler(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        messages: {
+            id: string;
+            emailId: string;
+            from: string;
+            to: string[];
+            cc: string[];
+            bcc: string[];
+            subject: string;
+            messageId: string;
+            attachments: {
+                id: string;
+                filename: string;
+                contentType: string;
+                contentDisposition?: string;
+                contentId?: string;
+            }[];
+            receivedAt: string;
+            content: string;
+            folder: MailFolder;
+            action?: string;
+            processing?: boolean;
+            processingStartedAt?: string;
+        }[];
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 500, "json">)>;
+/**
+ * GET /api/v1/mail/:folder/:id
+ * Get a specific email
+ */
+export declare function getMailHandler(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        message: {
+            id: string;
+            emailId: string;
+            from: string;
+            to: string[];
+            cc: string[];
+            bcc: string[];
+            subject: string;
+            messageId: string;
+            attachments: {
+                id: string;
+                filename: string;
+                contentType: string;
+                contentDisposition?: string;
+                contentId?: string;
+            }[];
+            receivedAt: string;
+            content: string;
+            folder: MailFolder;
+            action?: string;
+            processing?: boolean;
+            processingStartedAt?: string;
+        };
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 500, "json">)>;
+/**
+ * PUT /api/v1/mail/:id/status
+ * Set email read/unread status
+ */
+export declare function setMailStatusHandler(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        message: {
+            id: string;
+            emailId: string;
+            from: string;
+            to: string[];
+            cc: string[];
+            bcc: string[];
+            subject: string;
+            messageId: string;
+            attachments: {
+                id: string;
+                filename: string;
+                contentType: string;
+                contentDisposition?: string;
+                contentId?: string;
+            }[];
+            receivedAt: string;
+            content: string;
+            folder: MailFolder;
+            action?: string;
+            processing?: boolean;
+            processingStartedAt?: string;
+        };
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 404 | 500, "json">)>;
+/**
+ * POST /api/v1/mail/:id/reply
+ * Reply to an email
+ */
+export declare function replyMailHandler(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        message: {
+            id: string;
+            emailId: string;
+            from: string;
+            to: string[];
+            cc: string[];
+            bcc: string[];
+            subject: string;
+            messageId: string;
+            attachments: {
+                id: string;
+                filename: string;
+                contentType: string;
+                contentDisposition?: string;
+                contentId?: string;
+            }[];
+            receivedAt: string;
+            content: string;
+            folder: MailFolder;
+            action?: string;
+            processing?: boolean;
+            processingStartedAt?: string;
+        };
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 404 | 500, "json">)>;
+/**
+ * POST /api/v1/mail/send
+ * Send an email (coming soon)
+ */
+export declare function sendMailHandler(c: Context): Promise<Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 501, "json">>;
+/**
+ * DELETE /api/v1/mail/:folder/:id
+ * Delete an email
+ */
+export declare function deleteMailHandler(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 500, "json">)>;
+/**
+ * PUT /api/v1/mail/:id/action
+ * Set agent action summary on an email
+ */
+export declare function setMailActionHandler(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        message: {
+            id: string;
+            emailId: string;
+            from: string;
+            to: string[];
+            cc: string[];
+            bcc: string[];
+            subject: string;
+            messageId: string;
+            attachments: {
+                id: string;
+                filename: string;
+                contentType: string;
+                contentDisposition?: string;
+                contentId?: string;
+            }[];
+            receivedAt: string;
+            content: string;
+            folder: MailFolder;
+            action?: string;
+            processing?: boolean;
+            processingStartedAt?: string;
+        };
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 404 | 500, "json">)>;
+/**
+ * GET /api/v1/mail/:id/processing
+ * Get processing status and log tail for an email
+ */
+export declare function getMailProcessingHandler(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        mailId: string;
+        processing: boolean;
+        processingStartedAt: string;
+        active: {
+            pid: number;
+            agent: string;
+            startedAt: string;
+        };
+        log: string;
+        logPath: string;
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 500, "json">)>;
+/**
+ * POST /api/v1/mail/:id/processing/stop
+ * Stop an active mail processing job
+ */
+export declare function stopMailProcessingHandler(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 500, "json">)>;
+/**
+ * POST /api/v1/mail/inbound
+ * Receive email via Resend webhook
+ */
+export declare function inboundWebhookHandler(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    success: false;
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    data: {
+        message: {
+            id: string;
+            emailId: string;
+            from: string;
+            to: string[];
+            cc: string[];
+            bcc: string[];
+            subject: string;
+            messageId: string;
+            attachments: {
+                id: string;
+                filename: string;
+                contentType: string;
+                contentDisposition?: string;
+                contentId?: string;
+            }[];
+            receivedAt: string;
+            content: string;
+            folder: MailFolder;
+            action?: string;
+            processing?: boolean;
+            processingStartedAt?: string;
+        };
+    };
+}, 201, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 500, "json">)>;

package/dist/routes/api/v1/mail/route.js

@@ -0,0 +1,344 @@
+import { listMail, getMail, saveMail, setMailStatus, deleteMail, replyToMail, addMailAction, setMailProcessing, } from '@lovelybunch/core';
+import { getMailRunner } from '../../../../lib/mail/mail-runner.js';
+const VALID_FOLDERS = ['inbox', 'read', 'sent'];
+function isValidFolder(folder) {
+    return VALID_FOLDERS.includes(folder);
+}
+/**
+ * GET /api/v1/mail/:folder
+ * List emails in a folder
+ */
+export async function listMailHandler(c) {
+    try {
+        const folder = c.req.param('folder');
+        if (!isValidFolder(folder)) {
+            return c.json({
+                success: false,
+                error: `Invalid folder "${folder}". Must be one of: ${VALID_FOLDERS.join(', ')}`,
+            }, 400);
+        }
+        const messages = await listMail(folder);
+        return c.json({
+            success: true,
+            data: { messages },
+        });
+    }
+    catch (error) {
+        console.error('[mail] list error:', error);
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to list mail',
+        }, 500);
+    }
+}
+/**
+ * GET /api/v1/mail/:folder/:id
+ * Get a specific email
+ */
+export async function getMailHandler(c) {
+    try {
+        const folder = c.req.param('folder');
+        const id = c.req.param('id');
+        if (!isValidFolder(folder)) {
+            return c.json({
+                success: false,
+                error: `Invalid folder "${folder}". Must be one of: ${VALID_FOLDERS.join(', ')}`,
+            }, 400);
+        }
+        const message = await getMail(id, folder);
+        if (!message) {
+            return c.json({
+                success: false,
+                error: `Email "${id}" not found in ${folder}`,
+            }, 404);
+        }
+        return c.json({
+            success: true,
+            data: { message },
+        });
+    }
+    catch (error) {
+        console.error('[mail] get error:', error);
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to get mail',
+        }, 500);
+    }
+}
+/**
+ * PUT /api/v1/mail/:id/status
+ * Set email read/unread status
+ */
+export async function setMailStatusHandler(c) {
+    try {
+        const id = c.req.param('id');
+        const body = await c.req.json();
+        const status = body.status;
+        if (status !== 'read' && status !== 'unread') {
+            return c.json({
+                success: false,
+                error: 'Status must be "read" or "unread"',
+            }, 400);
+        }
+        const message = await setMailStatus(id, status);
+        return c.json({
+            success: true,
+            data: { message },
+        });
+    }
+    catch (error) {
+        console.error('[mail] setStatus error:', error);
+        const status = error.message?.includes('not found') ? 404 : 500;
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to set mail status',
+        }, status);
+    }
+}
+/**
+ * POST /api/v1/mail/:id/reply
+ * Reply to an email
+ */
+export async function replyMailHandler(c) {
+    try {
+        const id = c.req.param('id');
+        const body = await c.req.json();
+        if (!body.content || typeof body.content !== 'string') {
+            return c.json({
+                success: false,
+                error: 'Reply content is required',
+            }, 400);
+        }
+        const reply = await replyToMail(id, { content: body.content });
+        return c.json({
+            success: true,
+            data: { message: reply },
+        });
+    }
+    catch (error) {
+        console.error('[mail] reply error:', error);
+        const status = error.message?.includes('not found') ? 404 : 500;
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to reply to mail',
+        }, status);
+    }
+}
+/**
+ * POST /api/v1/mail/send
+ * Send an email (coming soon)
+ */
+export async function sendMailHandler(c) {
+    return c.json({
+        success: false,
+        error: 'Send email is coming soon',
+    }, 501);
+}
+/**
+ * DELETE /api/v1/mail/:folder/:id
+ * Delete an email
+ */
+export async function deleteMailHandler(c) {
+    try {
+        const folder = c.req.param('folder');
+        const id = c.req.param('id');
+        if (!isValidFolder(folder)) {
+            return c.json({
+                success: false,
+                error: `Invalid folder "${folder}". Must be one of: ${VALID_FOLDERS.join(', ')}`,
+            }, 400);
+        }
+        const deleted = await deleteMail(id, folder);
+        if (!deleted) {
+            return c.json({
+                success: false,
+                error: `Email "${id}" not found in ${folder}`,
+            }, 404);
+        }
+        return c.json({
+            success: true,
+            message: `Email "${id}" deleted from ${folder}`,
+        });
+    }
+    catch (error) {
+        console.error('[mail] delete error:', error);
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to delete mail',
+        }, 500);
+    }
+}
+/**
+ * PUT /api/v1/mail/:id/action
+ * Set agent action summary on an email
+ */
+export async function setMailActionHandler(c) {
+    try {
+        const id = c.req.param('id');
+        const body = await c.req.json();
+        if (!body.action || typeof body.action !== 'string') {
+            return c.json({
+                success: false,
+                error: 'Action message is required and must be a string',
+            }, 400);
+        }
+        const message = await addMailAction(id, body.action);
+        return c.json({
+            success: true,
+            data: { message },
+        });
+    }
+    catch (error) {
+        console.error('[mail] setAction error:', error);
+        const status = error.message?.includes('not found') ? 404 : 500;
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to set mail action',
+        }, status);
+    }
+}
+/**
+ * GET /api/v1/mail/:id/processing
+ * Get processing status and log tail for an email
+ */
+export async function getMailProcessingHandler(c) {
+    try {
+        const id = c.req.param('id');
+        const runner = getMailRunner();
+        const mail = await getMail(id);
+        if (!mail) {
+            return c.json({
+                success: false,
+                error: `Email "${id}" not found`,
+            }, 404);
+        }
+        const active = runner.getActiveProcess(id);
+        const logData = await runner.readLog(id);
+        return c.json({
+            success: true,
+            data: {
+                mailId: id,
+                processing: mail.processing || false,
+                processingStartedAt: mail.processingStartedAt || null,
+                active: active ? {
+                    pid: active.pid,
+                    agent: active.agent,
+                    startedAt: active.startedAt,
+                } : null,
+                log: logData?.log || null,
+                logPath: logData?.logPath || null,
+            },
+        });
+    }
+    catch (error) {
+        console.error('[mail] getProcessing error:', error);
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to get processing status',
+        }, 500);
+    }
+}
+/**
+ * POST /api/v1/mail/:id/processing/stop
+ * Stop an active mail processing job
+ */
+export async function stopMailProcessingHandler(c) {
+    try {
+        const id = c.req.param('id');
+        const runner = getMailRunner();
+        const active = runner.getActiveProcess(id);
+        if (!active) {
+            // No active process — clear the processing flag if still set
+            await setMailProcessing(id, false);
+            return c.json({
+                success: true,
+                message: `No active process found for "${id}". Processing flag cleared.`,
+            });
+        }
+        const stopped = await runner.stop(id);
+        if (!stopped) {
+            return c.json({
+                success: false,
+                error: `Failed to stop processing for "${id}"`,
+            }, 500);
+        }
+        return c.json({
+            success: true,
+            message: `Processing for "${id}" has been stopped (PID: ${active.pid}).`,
+        });
+    }
+    catch (error) {
+        console.error('[mail] stopProcessing error:', error);
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to stop processing',
+        }, 500);
+    }
+}
+/**
+ * POST /api/v1/mail/inbound
+ * Receive email via Resend webhook
+ */
+export async function inboundWebhookHandler(c) {
+    try {
+        const body = await c.req.json();
+        if (body.type !== 'email.received') {
+            return c.json({
+                success: false,
+                error: `Unsupported webhook type: ${body.type}`,
+            }, 400);
+        }
+        const data = body.data;
+        if (!data || !data.email_id) {
+            return c.json({
+                success: false,
+                error: 'Missing email data in webhook payload',
+            }, 400);
+        }
+        const attachments = Array.isArray(data.attachments)
+            ? data.attachments.map((a) => ({
+                id: a.id,
+                filename: a.filename,
+                contentType: a.content_type,
+                contentDisposition: a.content_disposition,
+                contentId: a.content_id,
+            }))
+            : [];
+        const message = await saveMail('inbox', {
+            emailId: data.email_id,
+            from: data.from || '',
+            to: Array.isArray(data.to) ? data.to : [],
+            cc: Array.isArray(data.cc) ? data.cc : [],
+            bcc: Array.isArray(data.bcc) ? data.bcc : [],
+            subject: data.subject || '(no subject)',
+            messageId: data.message_id || '',
+            attachments,
+            receivedAt: data.created_at || body.created_at || new Date().toISOString(),
+            content: data.body || data.text || data.html || '',
+        });
+        const runner = getMailRunner();
+        const mailEnabled = await runner.isMailProcessingEnabled();
+        if (mailEnabled) {
+            setMailProcessing(message.id, true).catch(err => {
+                console.warn('[mail] failed to set processing state:', err);
+            });
+            runner.run(message.id, `.nut/mail/inbox/${message.id}.md`).catch(err => {
+                console.error('[mail] agent processing failed:', err);
+            });
+        }
+        else {
+            console.log('[mail] processing disabled via config, skipping agent for', message.id);
+        }
+        return c.json({
+            success: true,
+            data: { message },
+        }, 201);
+    }
+    catch (error) {
+        console.error('[mail] inbound webhook error:', error);
+        return c.json({
+            success: false,
+            error: error.message || 'Failed to process inbound email',
+        }, 500);
+    }
+}