@lovelybunch/api 1.0.75-alpha.9 → 1.0.76-alpha.0

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

@@ -19,6 +19,8 @@ function resolveAgent(model) {
         return 'codex';
     if (lower.includes('droid') || lower.includes('factory'))
         return 'droid';
+    if (lower.includes('kiro'))
+        return 'kiro';
     return 'claude';
 }
 function buildCommand(agent, instruction, config) {
@@ -54,6 +56,10 @@ function buildCommand(agent, instruction, config) {
             mainCommand = `droid exec --auto high ${mcpFlags} ${quotedInstruction}`.trim();
             break;
         }
+        case 'kiro': {
+            mainCommand = `kiro-cli chat --no-interactive --trust-all-tools ${quotedInstruction}`;
+            break;
+        }
         case 'claude':
         default: {
             // Claude uses .mcp.json for MCP server configuration (no --mcp flag)
@@ -68,13 +74,15 @@ const CLI_AGENT_LABEL = {
     claude: 'Claude',
     gemini: 'Gemini',
     codex: 'Codex',
-    droid: 'Factory Droid'
+    droid: 'Factory Droid',
+    kiro: 'Kiro'
 };
 const CLI_AGENT_BINARY = {
     claude: 'claude',
     gemini: 'gemini',
     codex: 'codex',
-    droid: 'droid'
+    droid: 'droid',
+    kiro: 'kiro-cli'
 };
 const DEFAULT_MAX_RUNTIME_MS = 30 * 60 * 1000; // 30 minutes
 function getMaxRuntime() {

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,51 @@
+interface MailRunResult {
+    status: 'succeeded' | 'failed';
+    summary?: string;
+    outputPath?: string;
+    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 loadConfig;
+    private loadConfigModel;
+    isMailProcessingEnabled(): Promise<boolean>;
+    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;
+export {};

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

@@ -0,0 +1,342 @@
+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';
+    if (lower.includes('kiro'))
+        return 'kiro';
+    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 'kiro':
+            mainCommand = `kiro-cli chat --no-interactive --trust-all-tools ${quotedInstruction}`;
+            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',
+    kiro: 'Kiro'
+};
+const CLI_AGENT_BINARY = {
+    claude: 'claude',
+    gemini: 'gemini',
+    codex: 'codex',
+    droid: 'droid',
+    kiro: 'kiro-cli'
+};
+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;
+    activeProcesses = new Map();
+    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 loadConfig() {
+        const projectRoot = await this.projectRootPromise;
+        const configPath = path.join(projectRoot, '.nut', 'config.json');
+        try {
+            const raw = await fs.readFile(configPath, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async loadConfigModel() {
+        const config = await this.loadConfig();
+        return config?.ai?.model;
+    }
+    async isMailProcessingEnabled() {
+        const config = await this.loadConfig();
+        return config?.mail?.enabled ?? false;
+    }
+    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;
+    }
+    /**
+     * 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);
+        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 = [];
+        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) => {
+            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);
+            // 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);
+                summaryChunks.push(text);
+            });
+            child.stderr?.on('data', (chunk) => {
+                const text = chunk.toString();
+                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();
+                cleanup();
+                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();
+                cleanup();
+                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/lib/storage/file-storage.d.ts

@@ -1,30 +1,31 @@
-import { ChangeProposal, CPStatus } from '@lovelybunch/types';
-export interface CPFilter {
-    status?: CPStatus;
+import { Task, TaskStatus } from '@lovelybunch/types';
+export interface TaskFilter {
+    status?: TaskStatus;
     author?: string;
     priority?: string;
     tags?: string[];
     search?: string;
 }
 export interface StorageAdapter {
-    createCP(cp: ChangeProposal): Promise<void>;
-    getCP(id: string): Promise<ChangeProposal | null>;
-    updateCP(id: string, cp: Partial<ChangeProposal>): Promise<void>;
-    deleteCP(id: string): Promise<void>;
-    listCPs(filter?: CPFilter): Promise<ChangeProposal[]>;
-    searchCPs(query: string): Promise<ChangeProposal[]>;
+    createTask(task: Task): Promise<void>;
+    getTask(id: string): Promise<Task | null>;
+    updateTask(id: string, task: Partial<Task>): Promise<void>;
+    deleteTask(id: string): Promise<void>;
+    listTasks(filter?: TaskFilter): Promise<Task[]>;
+    searchTasks(query: string): Promise<Task[]>;
 }
 export declare class FileStorageAdapter implements StorageAdapter {
     private basePath;
     private sanitizeForYAML;
     constructor(basePath?: string);
     ensureDirectories(): Promise<void>;
-    createCP(cp: ChangeProposal): Promise<void>;
-    getCP(id: string): Promise<ChangeProposal | null>;
-    updateCP(id: string, updates: Partial<ChangeProposal>): Promise<void>;
-    deleteCP(id: string): Promise<void>;
-    listCPs(filter?: CPFilter): Promise<ChangeProposal[]>;
-    searchCPs(query: string): Promise<ChangeProposal[]>;
-    private frontmatterToCP;
+    createTask(task: Task): Promise<void>;
+    getTask(id: string): Promise<Task | null>;
+    updateTask(id: string, updates: Partial<Task>): Promise<void>;
+    deleteTask(id: string): Promise<void>;
+    listTasks(filter?: TaskFilter): Promise<Task[]>;
+    searchTasks(query: string): Promise<Task[]>;
+    private normalizeStepStatus;
+    private frontmatterToTask;
     private getDefaultContent;
 }