@lovelybunch/api 1.0.75-alpha.12 → 1.0.75-alpha.14

package/dist/lib/mail/mail-runner.d.ts

@@ -5,14 +5,44 @@ interface MailRunResult {
     error?: string;
     cliCommand: string;
 }
+export interface ActiveMailProcess {
+    mailId: string;
+    pid: number;
+    agent: string;
+    startedAt: string;
+    logPath: string;
+}
 export declare class MailRunner {
     private projectRootPromise;
+    private activeProcesses;
     constructor();
     private ensureCliAvailable;
     private ensureLogPath;
     private loadSystemPrompt;
     private loadConfigModel;
     private buildInstruction;
+    /**
+     * Get the status of an active mail processing job.
+     * Returns null if no active process exists for this mailId.
+     */
+    getActiveProcess(mailId: string): ActiveMailProcess | null;
+    /**
+     * Get all active mail processing jobs.
+     */
+    getActiveProcesses(): ActiveMailProcess[];
+    /**
+     * Read the latest log file for a mail processing job.
+     * Returns the tail of the log (up to maxBytes).
+     */
+    readLog(mailId: string, maxBytes?: number): Promise<{
+        log: string;
+        logPath: string;
+    } | null>;
+    /**
+     * Stop an active mail processing job.
+     * Sends SIGTERM, then SIGKILL after 5s.
+     */
+    stop(mailId: string): Promise<boolean>;
     run(mailId: string, mailFilePath: string): Promise<MailRunResult>;
 }
 export declare function getMailRunner(): MailRunner;

package/dist/lib/mail/mail-runner.js

@@ -74,6 +74,7 @@ function getMaxRuntime() {
 }
 export class MailRunner {
     projectRootPromise;
+    activeProcesses = new Map();
     constructor() {
         this.projectRootPromise = getProjectRoot();
     }
@@ -122,6 +123,97 @@ export class MailRunner {
             .replace(/\{\{mailId\}\}/g, mailId);
         return instruction;
     }
+    /**
+     * Get the status of an active mail processing job.
+     * Returns null if no active process exists for this mailId.
+     */
+    getActiveProcess(mailId) {
+        const tracked = this.activeProcesses.get(mailId);
+        if (!tracked || !tracked.child.pid)
+            return null;
+        return {
+            mailId,
+            pid: tracked.child.pid,
+            agent: tracked.agent,
+            startedAt: tracked.startedAt,
+            logPath: tracked.logPath,
+        };
+    }
+    /**
+     * Get all active mail processing jobs.
+     */
+    getActiveProcesses() {
+        const result = [];
+        for (const [mailId, tracked] of this.activeProcesses) {
+            if (tracked.child.pid) {
+                result.push({
+                    mailId,
+                    pid: tracked.child.pid,
+                    agent: tracked.agent,
+                    startedAt: tracked.startedAt,
+                    logPath: tracked.logPath,
+                });
+            }
+        }
+        return result;
+    }
+    /**
+     * Read the latest log file for a mail processing job.
+     * Returns the tail of the log (up to maxBytes).
+     */
+    async readLog(mailId, maxBytes = 8192) {
+        const projectRoot = await this.projectRootPromise;
+        const logsDir = path.join(projectRoot, '.nut', 'mail', 'logs', mailId);
+        let files;
+        try {
+            files = await fs.readdir(logsDir);
+        }
+        catch {
+            return null;
+        }
+        const logFiles = files.filter(f => f.endsWith('.log')).sort();
+        if (logFiles.length === 0)
+            return null;
+        const latestLog = path.join(logsDir, logFiles[logFiles.length - 1]);
+        try {
+            const stat = await fs.stat(latestLog);
+            const start = Math.max(0, stat.size - maxBytes);
+            const fh = await fs.open(latestLog, 'r');
+            try {
+                const buf = Buffer.alloc(Math.min(stat.size, maxBytes));
+                await fh.read(buf, 0, buf.length, start);
+                let log = buf.toString('utf-8');
+                if (start > 0) {
+                    log = '...' + log.slice(log.indexOf('\n') + 1);
+                }
+                return { log, logPath: path.relative(projectRoot, latestLog) };
+            }
+            finally {
+                await fh.close();
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Stop an active mail processing job.
+     * Sends SIGTERM, then SIGKILL after 5s.
+     */
+    async stop(mailId) {
+        const tracked = this.activeProcesses.get(mailId);
+        if (!tracked)
+            return false;
+        console.log(`[mail] Stopping processing for ${mailId} (PID: ${tracked.child.pid})`);
+        tracked.child.kill('SIGTERM');
+        setTimeout(() => {
+            try {
+                tracked.child.kill('SIGKILL');
+            }
+            catch { /* already dead */ }
+        }, 5000);
+        return true;
+    }
     async run(mailId, mailFilePath) {
         const model = await this.loadConfigModel();
         const agent = resolveAgent(model);
@@ -132,7 +224,8 @@ export class MailRunner {
         const logPath = await this.ensureLogPath(mailId);
         const logStream = createWriteStream(logPath, { flags: 'a' });
         const summaryChunks = [];
-        logStream.write(`[${new Date().toISOString()}] Starting mail processing for ${mailId} using ${agent} CLI\n`);
+        const startedAt = new Date().toISOString();
+        logStream.write(`[${startedAt}] Starting mail processing for ${mailId} using ${agent} CLI\n`);
         logStream.write(`Mail file: ${mailFilePath}\n`);
         logStream.write(`Command: ${shellCommand}\n`);
         return new Promise((resolve) => {
@@ -172,6 +265,14 @@ export class MailRunner {
                 child.kill('SIGTERM');
                 setTimeout(() => child.kill('SIGKILL'), 10_000);
             }, maxRuntime);
+            // Track the active process
+            this.activeProcesses.set(mailId, {
+                child,
+                agent: CLI_AGENT_LABEL[agent],
+                startedAt,
+                logPath: path.relative(projectRoot, logPath),
+                abortTimeout,
+            });
             child.stdout?.on('data', (chunk) => {
                 const text = chunk.toString();
                 logStream.write(text);
@@ -182,11 +283,15 @@ export class MailRunner {
                 logStream.write(text);
                 summaryChunks.push(text);
             });
+            const cleanup = () => {
+                this.activeProcesses.delete(mailId);
+                clearTimeout(abortTimeout);
+            };
             child.on('error', (error) => {
                 const message = `Failed to start CLI command: ${error.message}`;
                 logStream.write(`${message}\n`);
                 logStream.end();
-                clearTimeout(abortTimeout);
+                cleanup();
                 setMailProcessing(mailId, false).catch(err => console.warn('[mail] failed to clear processing:', err));
                 resolve({
                     status: 'failed',
@@ -200,7 +305,7 @@ export class MailRunner {
                 const status = code === 0 ? 'succeeded' : 'failed';
                 logStream.write(`\n[${new Date().toISOString()}] Mail processing for ${mailId} completed with exit code ${code}\n`);
                 logStream.end();
-                clearTimeout(abortTimeout);
+                cleanup();
                 setMailProcessing(mailId, false).catch(err => console.warn('[mail] failed to clear processing:', err));
                 const summary = summaryChunks.join('');
                 resolve({

package/dist/lib/storage/file-storage.js

@@ -77,6 +77,7 @@ export class FileStorageAdapter {
             updatedAt: updatedAt.toISOString(),
             status: task.status,
             priority: task.metadata.priority || 'medium',
+            ...(task.metadata.readiness != null && { readiness: task.metadata.readiness }),
             // Author information
             author: {
                 id: task.author.id,
@@ -258,21 +259,15 @@ export class FileStorageAdapter {
                 error: step.error,
                 executedAt: step.executedAt ? new Date(step.executedAt) : undefined
             })),
-            evidence: data.evidence || [],
-            policies: data.policies || [],
-            featureFlags: data.featureFlags || [],
-            experiments: data.experiments || [],
-            telemetryContracts: data.telemetryContracts || [],
-            releasePlan: data.releasePlan || { strategy: 'immediate' },
             status: data.status || 'draft',
             comments: normalizedComments,
             metadata: {
                 createdAt: new Date(data.createdAt || Date.now()),
                 updatedAt: new Date(data.updatedAt || Date.now()),
                 reviewers: data.reviewers || [],
-                aiInteractions: data.aiInteractions || [],
                 tags: data.tags || [],
                 priority: data.priority || 'medium',
+                ...(data.readiness != null && { readiness: data.readiness }),
             },
             content // Store the markdown content
         };

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

@@ -1,10 +1,13 @@
 import { Hono } from 'hono';
-import { listMailHandler, getMailHandler, setMailStatusHandler, setMailActionHandler, replyMailHandler, sendMailHandler, deleteMailHandler, inboundWebhookHandler, } from './route.js';
+import { listMailHandler, getMailHandler, setMailStatusHandler, setMailActionHandler, replyMailHandler, sendMailHandler, deleteMailHandler, inboundWebhookHandler, getMailProcessingHandler, stopMailProcessingHandler, } from './route.js';
 const mailRoutes = new Hono();
 // Resend inbound webhook
 mailRoutes.post('/inbound', inboundWebhookHandler);
 // Send email (coming soon)
 mailRoutes.post('/send', sendMailHandler);
+// Processing status and control
+mailRoutes.get('/:id/processing', getMailProcessingHandler);
+mailRoutes.post('/:id/processing/stop', stopMailProcessingHandler);
 // Set email status (read/unread)
 mailRoutes.put('/:id/status', setMailStatusHandler);
 // Set agent action summary

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

@@ -31,6 +31,7 @@ export declare function listMailHandler(c: Context): Promise<(Response & import(
             folder: MailFolder;
             action?: string;
             processing?: boolean;
+            processingStartedAt?: string;
         }[];
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
@@ -71,6 +72,7 @@ export declare function getMailHandler(c: Context): Promise<(Response & import("
             folder: MailFolder;
             action?: string;
             processing?: boolean;
+            processingStartedAt?: string;
         };
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
@@ -108,6 +110,7 @@ export declare function setMailStatusHandler(c: Context): Promise<(Response & im
             folder: MailFolder;
             action?: string;
             processing?: boolean;
+            processingStartedAt?: string;
         };
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
@@ -145,6 +148,7 @@ export declare function replyMailHandler(c: Context): Promise<(Response & import
             folder: MailFolder;
             action?: string;
             processing?: boolean;
+            processingStartedAt?: string;
         };
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
@@ -207,12 +211,49 @@ export declare function setMailActionHandler(c: Context): Promise<(Response & im
             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
@@ -244,6 +285,7 @@ export declare function inboundWebhookHandler(c: Context): Promise<(Response & i
             folder: MailFolder;
             action?: string;
             processing?: boolean;
+            processingStartedAt?: string;
         };
     };
 }, 201, "json">) | (Response & import("hono").TypedResponse<{

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

@@ -197,6 +197,84 @@ export async function setMailActionHandler(c) {
         }, 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

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

@@ -7,9 +7,6 @@ export declare function getConfig(c: Context): Promise<(Response & import("hono"
     success: true;
     data: {
         enabled: boolean;
-        channelId: string;
-        channelName: string;
-        siteUrl: string;
         notifications: {
             proposals: {
                 created: boolean;
@@ -24,6 +21,9 @@ export declare function getConfig(c: Context): Promise<(Response & import("hono"
                 merge: boolean;
             };
         };
+        channelId: string;
+        channelName: string;
+        siteUrl: string;
         hasBotToken: boolean;
         hasSigningSecret: boolean;
     };
@@ -39,9 +39,6 @@ export declare function updateConfig(c: Context): Promise<(Response & import("ho
     success: true;
     data: {
         enabled: boolean;
-        channelId: string;
-        channelName: string;
-        siteUrl: string;
         notifications: {
             proposals: {
                 created: boolean;
@@ -56,6 +53,9 @@ export declare function updateConfig(c: Context): Promise<(Response & import("ho
                 merge: boolean;
             };
         };
+        channelId: string;
+        channelName: string;
+        siteUrl: string;
         hasBotToken: boolean;
         hasSigningSecret: boolean;
     };