@lovelybunch/api 1.0.72-alpha.0 → 1.0.73

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

@@ -1,504 +0,0 @@
-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/slack/index.d.ts

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

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

@@ -1,15 +0,0 @@
-import { Hono } from 'hono';
-import { getConfig, updateConfig, testConnection, listChannels, sendTestNotification, sendExampleNotification } from './route.js';
-const slackRoutes = new Hono();
-// Configuration endpoints
-slackRoutes.get('/config', getConfig);
-slackRoutes.put('/config', updateConfig);
-// Connection testing
-slackRoutes.post('/test', testConnection);
-// Channel listing
-slackRoutes.get('/channels', listChannels);
-// Test notification
-slackRoutes.post('/notify', sendTestNotification);
-// Example notification for specific type
-slackRoutes.post('/notify/example', sendExampleNotification);
-export { slackRoutes };

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

@@ -1,122 +0,0 @@
-import { Context } from 'hono';
-/**
- * GET /api/v1/slack/config
- * Returns the current Slack configuration (tokens masked)
- */
-export declare function getConfig(c: Context): Promise<(Response & import("hono").TypedResponse<{
-    success: true;
-    data: {
-        enabled: boolean;
-        channelId: string;
-        channelName: string;
-        notifications: {
-            proposals: {
-                created: boolean;
-                statusChange: boolean;
-            };
-            jobs: {
-                completed: boolean;
-                failed: boolean;
-            };
-            git: {
-                push: boolean;
-                merge: boolean;
-            };
-        };
-        hasBotToken: boolean;
-        hasSigningSecret: boolean;
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    success: false;
-    error: any;
-}, 500, "json">)>;
-/**
- * PUT /api/v1/slack/config
- * Updates Slack configuration
- */
-export declare function updateConfig(c: Context): Promise<(Response & import("hono").TypedResponse<{
-    success: true;
-    data: {
-        enabled: boolean;
-        channelId: string;
-        channelName: string;
-        notifications: {
-            proposals: {
-                created: boolean;
-                statusChange: boolean;
-            };
-            jobs: {
-                completed: boolean;
-                failed: boolean;
-            };
-            git: {
-                push: boolean;
-                merge: boolean;
-            };
-        };
-        hasBotToken: boolean;
-        hasSigningSecret: boolean;
-    };
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    success: false;
-    error: any;
-}, 500, "json">)>;
-/**
- * POST /api/v1/slack/test
- * Tests the Slack connection using the configured bot token
- */
-export declare function testConnection(c: Context): Promise<(Response & import("hono").TypedResponse<{
-    success: true;
-    message: string;
-    teamName: string;
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    success: false;
-    error: string;
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    success: false;
-    error: any;
-}, 500, "json">)>;
-/**
- * GET /api/v1/slack/channels
- * Lists available Slack channels the bot can post to
- */
-export declare function listChannels(c: Context): Promise<(Response & import("hono").TypedResponse<{
-    success: true;
-    data: {
-        id: string;
-        name: string;
-        isPrivate: boolean;
-        isMember: boolean;
-    }[];
-}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
-    success: false;
-    error: any;
-}, 500, "json">)>;
-/**
- * POST /api/v1/slack/notify
- * Sends a test notification to the configured channel
- */
-export declare function sendTestNotification(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: string;
-}, 400, "json">) | (Response & import("hono").TypedResponse<{
-    success: false;
-    error: any;
-}, 500, "json">)>;
-/**
- * POST /api/v1/slack/notify/example
- * Sends an example notification for a specific notification type
- */
-export declare function sendExampleNotification(c: Context): Promise<(Response & import("hono").TypedResponse<{
-    success: false;
-    error: string;
-}, 400, "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">)>;