@lovelybunch/api 1.0.71 → 1.0.72-alpha.0

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

@@ -2,6 +2,7 @@ import { randomUUID } from 'crypto';
 import { JobStore } from './job-store.js';
 import { JobRunner } from './job-runner.js';
 import { getLogger, JobKinds } from '@lovelybunch/core/logging';
+import { getSlackService } from '../slack/slack-service.js';
 const DAY_TO_INDEX = {
     sunday: 0,
     monday: 1,
@@ -191,6 +192,15 @@ export class JobScheduler {
                         logPath: result.outputPath,
                     }
                 });
+                // Send Slack notification (non-blocking)
+                const notificationType = result.status === 'succeeded' ? 'job.completed' : 'job.failed';
+                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 (logError) {
                 console.error('Error logging job run end:', logError);
@@ -219,6 +229,13 @@ export class JobScheduler {
                         stack: error?.stack,
                     }
                 });
+                // Send Slack notification for job failure (non-blocking)
+                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 (logError) {
                 console.error('Error logging job run error:', logError);

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

@@ -0,0 +1,89 @@
+export interface SlackNotificationSettings {
+    proposals: {
+        created: boolean;
+        statusChange: boolean;
+    };
+    jobs: {
+        completed: boolean;
+        failed: boolean;
+    };
+    git: {
+        push: boolean;
+        merge: boolean;
+    };
+}
+export interface SlackConfig {
+    enabled: boolean;
+    botToken: string;
+    signingSecret: string;
+    channelId: string;
+    channelName: string;
+    notifications: SlackNotificationSettings;
+}
+export interface SlackChannel {
+    id: string;
+    name: string;
+    isPrivate: boolean;
+    isMember: boolean;
+}
+export interface ProposalNotificationPayload {
+    type: 'proposal.created' | 'proposal.statusChange';
+    proposalId: string;
+    intent: string;
+    status?: string;
+    previousStatus?: string;
+    author?: string;
+}
+export interface JobNotificationPayload {
+    type: 'job.completed' | 'job.failed';
+    jobId: string;
+    jobName: string;
+    duration?: number;
+    error?: string;
+}
+export interface GitNotificationPayload {
+    type: 'git.push' | 'git.merge';
+    branch: string;
+    targetBranch?: string;
+    commitCount?: number;
+    message?: string;
+}
+export type NotificationPayload = ProposalNotificationPayload | JobNotificationPayload | GitNotificationPayload;
+export type NotificationType = 'proposal.created' | 'proposal.statusChange' | 'job.completed' | 'job.failed' | 'git.push' | 'git.merge';
+declare class SlackService {
+    private client;
+    private config;
+    private getSettingsPath;
+    loadConfig(): Promise<SlackConfig>;
+    saveConfig(updates: Partial<SlackConfig>): Promise<SlackConfig>;
+    getConfigForDisplay(): Promise<Omit<SlackConfig, 'botToken' | 'signingSecret'> & {
+        hasBotToken: boolean;
+        hasSigningSecret: boolean;
+    }>;
+    private getClient;
+    testConnection(): Promise<{
+        success: boolean;
+        teamName?: string;
+        error?: string;
+    }>;
+    listChannels(): Promise<SlackChannel[]>;
+    sendNotification(payload: NotificationPayload): Promise<boolean>;
+    /**
+     * Send an example notification for testing a specific notification type.
+     * Bypasses the enabled check so users can test before enabling.
+     */
+    sendExampleNotification(notificationType: NotificationType): Promise<boolean>;
+    private getExamplePayload;
+    private isNotificationEnabled;
+    private formatNotification;
+    private formatProposalCreated;
+    private formatProposalStatusChange;
+    private formatJobCompleted;
+    private formatJobFailed;
+    private formatGitPush;
+    private formatGitMerge;
+    private getStatusEmoji;
+    clearCache(): void;
+}
+export declare function getSlackService(): SlackService;
+export { SlackService };

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

@@ -0,0 +1,504 @@
+import { WebClient, LogLevel } from '@slack/web-api';
+import { promises as fs, existsSync, mkdirSync } from 'fs';
+import path from 'path';
+import { getAppDataDir } from '@lovelybunch/core';
+const DEFAULT_CONFIG = {
+    enabled: false,
+    botToken: '',
+    signingSecret: '',
+    channelId: '',
+    channelName: '',
+    notifications: {
+        proposals: { created: true, statusChange: true },
+        jobs: { completed: true, failed: true },
+        git: { push: false, merge: true },
+    },
+};
+class SlackService {
+    client = null;
+    config = null;
+    getSettingsPath() {
+        const appDataDir = getAppDataDir();
+        // Ensure directory exists
+        if (!existsSync(appDataDir)) {
+            mkdirSync(appDataDir, { recursive: true });
+        }
+        return path.join(appDataDir, 'slack.json');
+    }
+    async loadConfig() {
+        if (this.config) {
+            return this.config;
+        }
+        const settingsPath = this.getSettingsPath();
+        try {
+            const raw = await fs.readFile(settingsPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            this.config = { ...DEFAULT_CONFIG, ...parsed };
+            return this.config;
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT') {
+                this.config = { ...DEFAULT_CONFIG };
+                return this.config;
+            }
+            console.warn('[slack-service] Failed to read slack.json:', error);
+            this.config = { ...DEFAULT_CONFIG };
+            return this.config;
+        }
+    }
+    async saveConfig(updates) {
+        const current = await this.loadConfig();
+        const updated = {
+            ...current,
+            ...updates,
+            notifications: {
+                ...current.notifications,
+                ...(updates.notifications || {}),
+                proposals: {
+                    ...current.notifications.proposals,
+                    ...(updates.notifications?.proposals || {}),
+                },
+                jobs: {
+                    ...current.notifications.jobs,
+                    ...(updates.notifications?.jobs || {}),
+                },
+                git: {
+                    ...current.notifications.git,
+                    ...(updates.notifications?.git || {}),
+                },
+            },
+        };
+        const settingsPath = this.getSettingsPath();
+        await fs.writeFile(settingsPath, JSON.stringify(updated, null, 2), 'utf-8');
+        // Reset cached config and client
+        this.config = updated;
+        this.client = null;
+        return updated;
+    }
+    async getConfigForDisplay() {
+        const config = await this.loadConfig();
+        return {
+            enabled: config.enabled,
+            channelId: config.channelId,
+            channelName: config.channelName,
+            notifications: config.notifications,
+            hasBotToken: !!config.botToken && config.botToken.length > 0,
+            hasSigningSecret: !!config.signingSecret && config.signingSecret.length > 0,
+        };
+    }
+    getClient() {
+        if (this.client) {
+            return this.client;
+        }
+        if (!this.config?.botToken) {
+            return null;
+        }
+        this.client = new WebClient(this.config.botToken, {
+            logLevel: LogLevel.WARN,
+        });
+        return this.client;
+    }
+    async testConnection() {
+        try {
+            await this.loadConfig();
+            const client = this.getClient();
+            if (!client) {
+                return { success: false, error: 'Bot token not configured' };
+            }
+            const result = await client.auth.test();
+            if (result.ok) {
+                return {
+                    success: true,
+                    teamName: result.team
+                };
+            }
+            else {
+                return { success: false, error: result.error || 'Unknown error' };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to connect to Slack'
+            };
+        }
+    }
+    async listChannels() {
+        try {
+            await this.loadConfig();
+            const client = this.getClient();
+            if (!client) {
+                throw new Error('Bot token not configured');
+            }
+            const channels = [];
+            let cursor;
+            // First try to fetch both public and private channels
+            // Fall back to public only if groups:read scope is missing
+            let channelTypes = 'public_channel,private_channel';
+            try {
+                // Test if we can list private channels
+                await client.conversations.list({ types: 'private_channel', limit: 1 });
+            }
+            catch (error) {
+                if (error.data?.error === 'missing_scope' && error.data?.needed === 'groups:read') {
+                    // Fall back to public channels only
+                    channelTypes = 'public_channel';
+                }
+            }
+            // Fetch channels
+            do {
+                const result = await client.conversations.list({
+                    types: channelTypes,
+                    limit: 200,
+                    cursor,
+                });
+                if (result.channels) {
+                    for (const channel of result.channels) {
+                        if (channel.id && channel.name) {
+                            channels.push({
+                                id: channel.id,
+                                name: channel.name,
+                                isPrivate: channel.is_private || false,
+                                isMember: channel.is_member || false,
+                            });
+                        }
+                    }
+                }
+                cursor = result.response_metadata?.next_cursor;
+            } while (cursor);
+            // Sort by name
+            channels.sort((a, b) => a.name.localeCompare(b.name));
+            return channels;
+        }
+        catch (error) {
+            console.error('[slack-service] Failed to list channels:', error);
+            // Provide helpful error messages for common Slack API errors
+            if (error.data?.error === 'missing_scope' || error.message?.includes('missing_scope')) {
+                throw new Error('Missing required Slack scopes. Please add "channels:read" (and optionally "groups:read" for private channels) to your Slack app under OAuth & Permissions.');
+            }
+            if (error.data?.error === 'invalid_auth' || error.message?.includes('invalid_auth')) {
+                throw new Error('Invalid bot token. Please check your Bot User OAuth Token.');
+            }
+            if (error.data?.error === 'token_revoked' || error.message?.includes('token_revoked')) {
+                throw new Error('Bot token has been revoked. Please reinstall the Slack app to your workspace.');
+            }
+            throw new Error(error.message || 'Failed to list channels');
+        }
+    }
+    async sendNotification(payload) {
+        try {
+            const config = await this.loadConfig();
+            if (!config.enabled || !config.channelId) {
+                return false;
+            }
+            // Check if this notification type is enabled
+            if (!this.isNotificationEnabled(config, payload)) {
+                return false;
+            }
+            const client = this.getClient();
+            if (!client) {
+                console.warn('[slack-service] Cannot send notification: bot token not configured');
+                return false;
+            }
+            const message = this.formatNotification(payload);
+            await client.chat.postMessage({
+                channel: config.channelId,
+                ...message,
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[slack-service] Failed to send notification:', error);
+            return false;
+        }
+    }
+    /**
+     * Send an example notification for testing a specific notification type.
+     * Bypasses the enabled check so users can test before enabling.
+     */
+    async sendExampleNotification(notificationType) {
+        try {
+            const config = await this.loadConfig();
+            if (!config.channelId) {
+                throw new Error('No channel configured. Please select a channel first.');
+            }
+            const client = this.getClient();
+            if (!client) {
+                throw new Error('Bot token not configured');
+            }
+            const payload = this.getExamplePayload(notificationType);
+            const message = this.formatNotification(payload);
+            await client.chat.postMessage({
+                channel: config.channelId,
+                ...message,
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('[slack-service] Failed to send example notification:', error);
+            throw error;
+        }
+    }
+    getExamplePayload(type) {
+        switch (type) {
+            case 'proposal.created':
+                return {
+                    type: 'proposal.created',
+                    proposalId: 'cp-example-123',
+                    intent: 'Add user authentication flow',
+                    author: 'Example User',
+                };
+            case 'proposal.statusChange':
+                return {
+                    type: 'proposal.statusChange',
+                    proposalId: 'cp-example-123',
+                    intent: 'Add user authentication flow',
+                    status: 'proposed',
+                    previousStatus: 'draft',
+                };
+            case 'job.completed':
+                return {
+                    type: 'job.completed',
+                    jobId: 'job-example-456',
+                    jobName: 'Daily code review sync',
+                    duration: 45000,
+                };
+            case 'job.failed':
+                return {
+                    type: 'job.failed',
+                    jobId: 'job-example-456',
+                    jobName: 'Daily code review sync',
+                    error: 'Connection timeout after 30 seconds',
+                };
+            case 'git.push':
+                return {
+                    type: 'git.push',
+                    branch: 'feature/example-branch',
+                    commitCount: 3,
+                };
+            case 'git.merge':
+                return {
+                    type: 'git.merge',
+                    branch: 'feature/example-branch',
+                    targetBranch: 'main',
+                    message: 'Merged feature branch into main',
+                };
+            default:
+                throw new Error(`Unknown notification type: ${type}`);
+        }
+    }
+    isNotificationEnabled(config, payload) {
+        switch (payload.type) {
+            case 'proposal.created':
+                return config.notifications.proposals.created;
+            case 'proposal.statusChange':
+                return config.notifications.proposals.statusChange;
+            case 'job.completed':
+                return config.notifications.jobs.completed;
+            case 'job.failed':
+                return config.notifications.jobs.failed;
+            case 'git.push':
+                return config.notifications.git.push;
+            case 'git.merge':
+                return config.notifications.git.merge;
+            default:
+                return false;
+        }
+    }
+    formatNotification(payload) {
+        switch (payload.type) {
+            case 'proposal.created':
+                return this.formatProposalCreated(payload);
+            case 'proposal.statusChange':
+                return this.formatProposalStatusChange(payload);
+            case 'job.completed':
+                return this.formatJobCompleted(payload);
+            case 'job.failed':
+                return this.formatJobFailed(payload);
+            case 'git.push':
+                return this.formatGitPush(payload);
+            case 'git.merge':
+                return this.formatGitMerge(payload);
+            default:
+                return { text: 'Unknown notification type' };
+        }
+    }
+    formatProposalCreated(payload) {
+        const text = `New proposal created: ${payload.intent}`;
+        return {
+            text,
+            blocks: [
+                {
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `:memo: *New Proposal Created*\n*${payload.intent}*\nA new change proposal has been submitted for review.`,
+                    },
+                },
+                {
+                    type: 'context',
+                    elements: [
+                        {
+                            type: 'mrkdwn',
+                            text: `ID: \`${payload.proposalId}\`${payload.author ? ` | Author: ${payload.author}` : ''}`,
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    formatProposalStatusChange(payload) {
+        const statusEmoji = this.getStatusEmoji(payload.status);
+        const text = `Proposal status changed: ${payload.intent} → ${payload.status}`;
+        return {
+            text,
+            blocks: [
+                {
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `${statusEmoji} *Proposal Status Changed*\n*${payload.intent}*\nThe proposal has moved to a new stage in the review process.`,
+                    },
+                },
+                {
+                    type: 'context',
+                    elements: [
+                        {
+                            type: 'mrkdwn',
+                            text: `\`${payload.previousStatus || 'unknown'}\` → \`${payload.status}\` | ID: \`${payload.proposalId}\``,
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    formatJobCompleted(payload) {
+        const duration = payload.duration ? `${Math.round(payload.duration / 1000)}s` : 'unknown';
+        const text = `Job completed: ${payload.jobName}`;
+        return {
+            text,
+            blocks: [
+                {
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `:white_check_mark: *Job Completed*\n*${payload.jobName}*\nThe scheduled job finished successfully.`,
+                    },
+                },
+                {
+                    type: 'context',
+                    elements: [
+                        {
+                            type: 'mrkdwn',
+                            text: `Duration: ${duration} | ID: \`${payload.jobId}\``,
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    formatJobFailed(payload) {
+        const text = `Job failed: ${payload.jobName}`;
+        return {
+            text,
+            blocks: [
+                {
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `:x: *Job Failed*\n*${payload.jobName}*\nThe scheduled job encountered an error and did not complete.`,
+                    },
+                },
+                {
+                    type: 'context',
+                    elements: [
+                        {
+                            type: 'mrkdwn',
+                            text: `ID: \`${payload.jobId}\`${payload.error ? `\nError: ${payload.error.slice(0, 200)}` : ''}`,
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    formatGitPush(payload) {
+        const text = `Pushed to ${payload.branch}`;
+        return {
+            text,
+            blocks: [
+                {
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `:arrow_up: *Git Push*\nPushed to \`${payload.branch}\`\nCode changes have been pushed to the remote repository.`,
+                    },
+                },
+                {
+                    type: 'context',
+                    elements: [
+                        {
+                            type: 'mrkdwn',
+                            text: payload.commitCount ? `${payload.commitCount} commit(s)` : 'Commits pushed',
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    formatGitMerge(payload) {
+        const text = `Merged ${payload.branch} into ${payload.targetBranch}`;
+        return {
+            text,
+            blocks: [
+                {
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `:twisted_rightwards_arrows: *Git Merge*\nMerged \`${payload.branch}\` into \`${payload.targetBranch || 'target'}\`\nBranches have been combined successfully.`,
+                    },
+                },
+                {
+                    type: 'context',
+                    elements: [
+                        {
+                            type: 'mrkdwn',
+                            text: payload.message || 'Merge completed',
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    getStatusEmoji(status) {
+        switch (status) {
+            case 'approved':
+                return ':white_check_mark:';
+            case 'merged':
+                return ':tada:';
+            case 'rejected':
+                return ':no_entry:';
+            case 'in-review':
+                return ':eyes:';
+            case 'proposed':
+                return ':raising_hand:';
+            case 'draft':
+                return ':pencil2:';
+            default:
+                return ':arrows_counterclockwise:';
+        }
+    }
+    // Clear cached state (useful for testing or config changes)
+    clearCache() {
+        this.config = null;
+        this.client = null;
+    }
+}
+// Singleton instance
+let slackServiceInstance = null;
+export function getSlackService() {
+    if (!slackServiceInstance) {
+        slackServiceInstance = new SlackService();
+    }
+    return slackServiceInstance;
+}
+export { SlackService };

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

@@ -7,6 +7,7 @@ import { resolveCoconutId, resolveControlPlaneUrl } from '../../../../lib/coconu
 import { loadGitSettings, saveGitSettings, isGitAuthMode } from '../../../../lib/git-settings.js';
 import { getLogger, CodeKinds } from '@lovelybunch/core/logging';
 import { requireAuth } from '../../../../middleware/auth.js';
+import { getSlackService } from '../../../../lib/slack/slack-service.js';
 const app = new Hono();
 // Settings
 app.get('/settings', async (c) => {
@@ -330,7 +331,18 @@ app.post('/branches/:branch/merge', async (c) => {
         }
         catch { }
         const mergeStrategy = strategy?.strategy === 'squash' || strategy?.strategy === 'rebase' ? strategy.strategy : 'merge';
+        // Get current branch (target) before merge
+        const { runGit } = await import('../../../../lib/git.js');
+        const { stdout: branchOutput } = await runGit(['branch', '--show-current']);
+        const targetBranch = branchOutput.trim();
         const result = await mergeBranch(name, mergeStrategy);
+        // Send Slack notification (non-blocking)
+        getSlackService().sendNotification({
+            type: 'git.merge',
+            branch: name,
+            targetBranch,
+            message: `Merged ${name} into ${targetBranch} using ${mergeStrategy}`,
+        }).catch(err => console.warn('[git] Slack notification failed:', err));
         return c.json({ success: true, data: { branch: name, strategy: mergeStrategy, result } });
     }
     catch (e) {
@@ -466,6 +478,11 @@ app.post('/push', async (c) => {
                     remote: remoteName,
                 }
             });
+            // Send Slack notification (non-blocking)
+            getSlackService().sendNotification({
+                type: 'git.push',
+                branch: currentBranch,
+            }).catch(err => console.warn('[git] Slack notification failed:', err));
         }
         catch (logError) {
             console.error('Error logging push:', logError);

package/dist/routes/api/v1/proposals/[id]/route.js

@@ -1,5 +1,6 @@
 import { FileStorageAdapter } from '../../../../../lib/storage/file-storage.js';
 import { getLogger } from '@lovelybunch/core/logging';
+import { getSlackService } from '../../../../../lib/slack/slack-service.js';
 const storage = new FileStorageAdapter();
 // Logger is lazily initialized inside handlers to use server config
 export async function GET(c) {
@@ -90,6 +91,14 @@ export async function PATCH(c) {
                     reason: null
                 }
             });
+            // Send Slack notification for status change (non-blocking)
+            getSlackService().sendNotification({
+                type: 'proposal.statusChange',
+                proposalId: id,
+                intent: updatedProposal?.intent || existing.intent,
+                status: newStatus,
+                previousStatus: oldStatus,
+            }).catch(err => console.warn('[proposals] Slack notification failed:', err));
         }
         return c.json({
             success: true,