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

package/dist/lib/jobs/job-scheduler.js

@@ -195,6 +195,18 @@ export class JobScheduler {
             catch (logError) {
                 console.error('Error logging job run end:', logError);
             }
+            // Send Slack notification for job completion (non-blocking)
+            const notificationType = result.status === 'succeeded' ? 'job.completed' : 'job.failed';
+            import('../slack/slack-service.js').then(({ getSlackService }) => {
+                const duration = runRecord.finishedAt.getTime() - start.getTime();
+                getSlackService().sendNotification({
+                    type: notificationType,
+                    jobId: job.id,
+                    jobName: job.name || job.id,
+                    duration,
+                    error: result.error,
+                }).catch(err => console.warn('[jobs] Slack notification failed:', err));
+            }).catch(() => { });
         }
         catch (error) {
             runRecord.status = 'failed';
@@ -223,6 +235,15 @@ export class JobScheduler {
             catch (logError) {
                 console.error('Error logging job run error:', logError);
             }
+            // Send Slack notification for job failure (non-blocking)
+            import('../slack/slack-service.js').then(({ getSlackService }) => {
+                getSlackService().sendNotification({
+                    type: 'job.failed',
+                    jobId: job.id,
+                    jobName: job.name || job.id,
+                    error: error?.message || 'Unknown error',
+                }).catch(err => console.warn('[jobs] Slack notification failed:', err));
+            }).catch(() => { });
         }
         try {
             await this.store.saveJob(job);

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

@@ -0,0 +1,19 @@
+interface MailRunResult {
+    status: 'succeeded' | 'failed';
+    summary?: string;
+    outputPath?: string;
+    error?: string;
+    cliCommand: string;
+}
+export declare class MailRunner {
+    private projectRootPromise;
+    constructor();
+    private ensureCliAvailable;
+    private ensureLogPath;
+    private loadSystemPrompt;
+    private loadConfigModel;
+    private buildInstruction;
+    run(mailId: string, mailFilePath: string): Promise<MailRunResult>;
+}
+export declare function getMailRunner(): MailRunner;
+export {};

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

@@ -0,0 +1,223 @@
+import { spawn, spawnSync } from 'child_process';
+import { createWriteStream } from 'fs';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { getProjectRoot } from '../project-paths.js';
+import { getInjectedEnv } from '../env-injection.js';
+import { setMailProcessing } from '@lovelybunch/core';
+function shellQuote(value) {
+    if (value === '')
+        return "''";
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function resolveAgent(model) {
+    if (!model)
+        return 'claude';
+    const lower = model.toLowerCase();
+    if (lower.includes('gemini'))
+        return 'gemini';
+    if (lower.includes('codex') || lower.includes('gpt') || lower.includes('openai'))
+        return 'codex';
+    if (lower.includes('droid') || lower.includes('factory'))
+        return 'droid';
+    return 'claude';
+}
+function buildCommand(agent, instruction, runningAsRoot) {
+    const quotedInstruction = shellQuote(instruction);
+    let mainCommand = '';
+    switch (agent) {
+        case 'gemini':
+            mainCommand = `gemini --yolo -i ${quotedInstruction}`;
+            break;
+        case 'codex': {
+            const baseCmd = `codex ${quotedInstruction} --dangerously-bypass-approvals-and-sandbox`.trim();
+            const needsPseudoTty = runningAsRoot && process.platform !== 'win32';
+            mainCommand = needsPseudoTty
+                ? `script -q -e -c ${shellQuote(baseCmd)} /dev/null`
+                : baseCmd;
+            break;
+        }
+        case 'droid':
+            mainCommand = `droid exec --auto high ${quotedInstruction}`.trim();
+            break;
+        case 'claude':
+        default: {
+            const prefix = runningAsRoot ? 'IS_SANDBOX=1 ' : '';
+            mainCommand = `${prefix}claude ${quotedInstruction} --dangerously-skip-permissions`.trim();
+            break;
+        }
+    }
+    return { command: agent === 'claude' ? 'claude' : agent, shellCommand: mainCommand };
+}
+const CLI_AGENT_LABEL = {
+    claude: 'Claude',
+    gemini: 'Gemini',
+    codex: 'Codex',
+    droid: 'Factory Droid'
+};
+const CLI_AGENT_BINARY = {
+    claude: 'claude',
+    gemini: 'gemini',
+    codex: 'codex',
+    droid: 'droid'
+};
+const DEFAULT_MAX_RUNTIME_MS = 15 * 60 * 1000; // 15 minutes for mail processing
+function getMaxRuntime() {
+    const raw = process.env.COCONUT_MAIL_MAX_RUNTIME_MS;
+    if (!raw)
+        return DEFAULT_MAX_RUNTIME_MS;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return DEFAULT_MAX_RUNTIME_MS;
+    }
+    return parsed;
+}
+export class MailRunner {
+    projectRootPromise;
+    constructor() {
+        this.projectRootPromise = getProjectRoot();
+    }
+    ensureCliAvailable(agent) {
+        const binary = CLI_AGENT_BINARY[agent];
+        const result = spawnSync('bash', ['-lc', `command -v ${binary}`], { stdio: 'ignore' });
+        if (result.status !== 0) {
+            throw new Error(`${CLI_AGENT_LABEL[agent]} CLI ("${binary}") is not installed or not on PATH.`);
+        }
+    }
+    async ensureLogPath(mailId) {
+        const projectRoot = await this.projectRootPromise;
+        const logsDir = path.join(projectRoot, '.nut', 'mail', 'logs', mailId);
+        await fs.mkdir(logsDir, { recursive: true });
+        const runId = `run-${Date.now()}`;
+        return path.join(logsDir, `${runId}.log`);
+    }
+    async loadSystemPrompt() {
+        const projectRoot = await this.projectRootPromise;
+        // Look for the system prompt in the shared package (relative to project root)
+        const promptPath = path.join(projectRoot, 'packages', 'shared', 'system-prompts', 'mail-processor.md');
+        try {
+            return await fs.readFile(promptPath, 'utf-8');
+        }
+        catch (err) {
+            throw new Error(`Failed to load mail processor system prompt from ${promptPath}: ${err.message}`);
+        }
+    }
+    async loadConfigModel() {
+        const projectRoot = await this.projectRootPromise;
+        const configPath = path.join(projectRoot, '.nut', 'config.json');
+        try {
+            const raw = await fs.readFile(configPath, 'utf-8');
+            const config = JSON.parse(raw);
+            return config?.ai?.model;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async buildInstruction(mailId, mailFilePath) {
+        const systemPrompt = await this.loadSystemPrompt();
+        // Substitute placeholders in the system prompt
+        const instruction = systemPrompt
+            .replace(/\{\{mailFilePath\}\}/g, mailFilePath)
+            .replace(/\{\{mailId\}\}/g, mailId);
+        return instruction;
+    }
+    async run(mailId, mailFilePath) {
+        const model = await this.loadConfigModel();
+        const agent = resolveAgent(model);
+        const instruction = await this.buildInstruction(mailId, mailFilePath);
+        const runningAsRoot = typeof process.getuid === 'function' && process.getuid() === 0;
+        const { shellCommand } = buildCommand(agent, instruction, runningAsRoot);
+        const projectRoot = await this.projectRootPromise;
+        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`);
+        logStream.write(`Mail file: ${mailFilePath}\n`);
+        logStream.write(`Command: ${shellCommand}\n`);
+        return new Promise((resolve) => {
+            let cliMissingError = null;
+            try {
+                this.ensureCliAvailable(agent);
+            }
+            catch (error) {
+                cliMissingError = error instanceof Error ? error : new Error(String(error));
+            }
+            if (cliMissingError) {
+                const message = cliMissingError.message;
+                logStream.write(`${message}\n`);
+                logStream.end();
+                setMailProcessing(mailId, false).catch(err => console.warn('[mail] failed to clear processing:', err));
+                resolve({
+                    status: 'failed',
+                    error: message,
+                    summary: message,
+                    outputPath: path.relative(projectRoot, logPath),
+                    cliCommand: shellCommand,
+                });
+                return;
+            }
+            const injectedEnv = getInjectedEnv();
+            const child = spawn('bash', ['-lc', shellCommand], {
+                cwd: projectRoot,
+                env: {
+                    ...process.env,
+                    ...injectedEnv
+                },
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            const maxRuntime = getMaxRuntime();
+            const abortTimeout = setTimeout(() => {
+                logStream.write(`\n[${new Date().toISOString()}] Max runtime ${maxRuntime}ms exceeded. Sending SIGTERM...\n`);
+                child.kill('SIGTERM');
+                setTimeout(() => child.kill('SIGKILL'), 10_000);
+            }, maxRuntime);
+            child.stdout?.on('data', (chunk) => {
+                const text = chunk.toString();
+                logStream.write(text);
+                summaryChunks.push(text);
+            });
+            child.stderr?.on('data', (chunk) => {
+                const text = chunk.toString();
+                logStream.write(text);
+                summaryChunks.push(text);
+            });
+            child.on('error', (error) => {
+                const message = `Failed to start CLI command: ${error.message}`;
+                logStream.write(`${message}\n`);
+                logStream.end();
+                clearTimeout(abortTimeout);
+                setMailProcessing(mailId, false).catch(err => console.warn('[mail] failed to clear processing:', err));
+                resolve({
+                    status: 'failed',
+                    error: message,
+                    summary: summaryChunks.join('').slice(-600),
+                    outputPath: path.relative(projectRoot, logPath),
+                    cliCommand: shellCommand,
+                });
+            });
+            child.on('close', (code) => {
+                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);
+                setMailProcessing(mailId, false).catch(err => console.warn('[mail] failed to clear processing:', err));
+                const summary = summaryChunks.join('');
+                resolve({
+                    status,
+                    summary: summary.slice(Math.max(0, summary.length - 2000)),
+                    outputPath: path.relative(projectRoot, logPath),
+                    error: code === 0 ? undefined : `CLI exited with code ${code}`,
+                    cliCommand: shellCommand,
+                });
+            });
+        });
+    }
+}
+let mailRunnerInstance = null;
+export function getMailRunner() {
+    if (!mailRunnerInstance) {
+        mailRunnerInstance = new MailRunner();
+    }
+    return mailRunnerInstance;
+}

package/dist/lib/slack/slack-service.d.ts

@@ -0,0 +1,2 @@
+export { SlackService, getSlackService, DEFAULT_SLACK_CONFIG, } from '@lovelybunch/core';
+export type { SlackConfig, SlackNotificationSettings, SlackChannel, ProposalNotificationPayload, JobNotificationPayload, GitNotificationPayload, NotificationPayload, NotificationType, FreeformMessageOptions, } from '@lovelybunch/core';

package/dist/lib/slack/slack-service.js

@@ -0,0 +1,3 @@
+// Re-export from @lovelybunch/core for backward compatibility
+// All Slack logic now lives in packages/core/src/slack.ts
+export { SlackService, getSlackService, DEFAULT_SLACK_CONFIG, } from '@lovelybunch/core';

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

@@ -188,12 +188,32 @@ async function executeTasksToolDirect(args, _storage) {
     try {
         switch (operation) {
             case 'list': {
+                const DEFAULT_LIST_LIMIT = 20;
+                const requestedLimit = filters?.limit;
+                const effectiveLimit = requestedLimit ?? DEFAULT_LIST_LIMIT;
                 const tasks = await listTasks(filters || {});
+                const totalCount = tasks.length;
+                const limited = tasks.slice(0, effectiveLimit);
+                // Return lightweight summaries to keep token usage manageable.
+                // The AI can use "get" with a specific task ID to retrieve full details.
+                const summaries = limited.map((t) => ({
+                    id: t.id,
+                    title: t.title,
+                    status: t.status,
+                    priority: t.metadata?.priority,
+                    tags: t.metadata?.tags,
+                    author: t.author ? { name: t.author.name, type: t.author.type } : undefined,
+                    createdAt: t.metadata?.createdAt,
+                    updatedAt: t.metadata?.updatedAt,
+                }));
                 return {
                     success: true,
-                    data: tasks,
-                    count: tasks.length,
-                    message: `Found ${tasks.length} tasks`
+                    data: summaries,
+                    count: summaries.length,
+                    totalCount,
+                    message: totalCount > effectiveLimit
+                        ? `Showing ${summaries.length} of ${totalCount} tasks (limit: ${effectiveLimit}). Use filters or increase limit to see more. Use "get" with a task ID for full details.`
+                        : `Found ${totalCount} tasks. Use "get" with a task ID for full details.`
                 };
             }
             case 'get': {

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

@@ -331,6 +331,22 @@ app.post('/branches/:branch/merge', async (c) => {
         catch { }
         const mergeStrategy = strategy?.strategy === 'squash' || strategy?.strategy === 'rebase' ? strategy.strategy : 'merge';
         const result = await mergeBranch(name, mergeStrategy);
+        // Determine target branch for notification
+        try {
+            const { runGit } = await import('../../../../lib/git.js');
+            const { stdout: branchOutput } = await runGit(['branch', '--show-current']);
+            const targetBranch = branchOutput.trim();
+            // Send Slack notification (non-blocking)
+            import('../../../../lib/slack/slack-service.js').then(({ getSlackService }) => {
+                getSlackService().sendNotification({
+                    type: 'git.merge',
+                    branch: name,
+                    targetBranch,
+                    message: `Merged ${name} into ${targetBranch} using ${mergeStrategy}`,
+                }).catch(err => console.warn('[git] Slack notification failed:', err));
+            }).catch(() => { });
+        }
+        catch { }
         return c.json({ success: true, data: { branch: name, strategy: mergeStrategy, result } });
     }
     catch (e) {
@@ -466,6 +482,13 @@ app.post('/push', async (c) => {
                     remote: remoteName,
                 }
             });
+            // Send Slack notification (non-blocking)
+            import('../../../../lib/slack/slack-service.js').then(({ getSlackService }) => {
+                getSlackService().sendNotification({
+                    type: 'git.push',
+                    branch: currentBranch,
+                }).catch(err => console.warn('[git] Slack notification failed:', err));
+            }).catch(() => { });
         }
         catch (logError) {
             console.error('Error logging push:', logError);

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

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const mailRoutes: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export { mailRoutes };

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

@@ -0,0 +1,20 @@
+import { Hono } from 'hono';
+import { listMailHandler, getMailHandler, setMailStatusHandler, setMailActionHandler, replyMailHandler, sendMailHandler, deleteMailHandler, inboundWebhookHandler, } from './route.js';
+const mailRoutes = new Hono();
+// Resend inbound webhook
+mailRoutes.post('/inbound', inboundWebhookHandler);
+// Send email (coming soon)
+mailRoutes.post('/send', sendMailHandler);
+// Set email status (read/unread)
+mailRoutes.put('/:id/status', setMailStatusHandler);
+// Set agent action summary
+mailRoutes.put('/:id/action', setMailActionHandler);
+// Reply to email
+mailRoutes.post('/:id/reply', replyMailHandler);
+// List emails in folder
+mailRoutes.get('/:folder', listMailHandler);
+// Get specific email in folder
+mailRoutes.get('/:folder/:id', getMailHandler);
+// Delete email from folder
+mailRoutes.delete('/:folder/:id', deleteMailHandler);
+export { mailRoutes };

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

@@ -0,0 +1,252 @@
+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;
+        }[];
+    };
+}, 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;
+        };
+    };
+}, 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;
+        };
+    };
+}, 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;
+        };
+    };
+}, 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;
+        };
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 404 | 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;
+        };
+    };
+}, 201, "json">) | (Response & import("hono").TypedResponse<{
+    success: false;
+    error: any;
+}, 500, "json">)>;