Add Fireflies Connector

src/api/rest/v1/fireflies/controller.ts

@@ -0,0 +1,21 @@
+import { Request, Response, NextFunction } from "express";
+
+export default class Controller {
+    public static async apiKeySubmit(req: Request, res: Response, next: NextFunction) {
+        try {
+            const apiKey = req.body.apiKey;
+
+            // @todo Validate API key if any (pending from FireFlies)
+
+            // Redirect to the callback endpoint with the apiKey            
+            res.status(200).send({
+                redirect: `/callback/fireflies?apiKey=${encodeURIComponent(apiKey)}`
+            });
+
+        } catch (error) {
+            res.status(400).send({
+                error: error.message
+            });
+        }
+    }
+}

src/api/rest/v1/fireflies/routes.ts

@@ -0,0 +1,8 @@
+import express from 'express'
+import Controller from './controller'
+
+const router = express.Router()
+
+router.post('/apiKeySubmit', Controller.apiKeySubmit)
+
+export default router

src/api/rest/v1/routes.ts

@@ -9,6 +9,7 @@ import AdminRoutes from './admin/routes'
 import InfoRoutes from './info/routes'
 import LLMRoutes from './llm/routes'
 import TelegramRoutes from './telegram/routes'
+import FireFliesRoutes from './fireflies/routes'
 import SearchRoutes from "./search/routes"
 import AccountRoutes from './account/routes'
 import AuthRoutes from "./auth/routes"
@@ -30,5 +31,6 @@ router.use('/account', AccountRoutes)
 router.use('/app', AppRoutes)
 
 router.use('/telegram', TelegramRoutes)
+router.use('/fireflies', FireFliesRoutes)
 
 export default router

src/providers/fireflies/README.md

@@ -0,0 +1,10 @@
+## Authentication
+
+Fireflies uses API key authentication and GraphQL for all API interactions.
+
+#### Getting an API Key
+
+1. Log in to your Fireflies.ai account
+2. Navigate to Settings > Developer Settings
+3. Use the existing one or reset another
+4. Copy and securely store your API key

src/providers/fireflies/api.ts

@@ -0,0 +1,90 @@
+import axios, { AxiosResponse } from 'axios';
+
+export interface FireFliesConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+
+export interface User {
+    user_id: string;
+    name: string;
+    email: string;
+    is_admin?: string;
+    num_transcripts?: string;
+    integrations?: string[]; 
+
+}
+
+export interface GraphQLResponse<T> {
+    data: T;
+    errors?: { message: string }[];
+}
+
+export class FireFliesClient {
+    private apiKey: string;
+    private baseUrl: string;
+
+    constructor(config: FireFliesConfig) {
+        this.apiKey = config.apiKey;
+        this.baseUrl = config.baseUrl || 'https://api.fireflies.ai/graphql';
+    }
+
+    private get headers() {
+        return {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${this.apiKey}`
+        };
+    }
+
+    public async executeQuery<T>(query: string, variables?: Record<string, any>): Promise<GraphQLResponse<T>> {
+        const payload = { query, variables };
+
+        try {
+            const response: AxiosResponse<GraphQLResponse<T>> = await axios.post(this.baseUrl, payload, { headers: this.headers });
+            if (response.data.errors) {
+                throw new Error(`GraphQL error: ${response.data.errors.map(e => e.message).join(', ')}`);
+            }
+            return response.data;
+        } catch (error) {
+            console.error('Error executing GraphQL query:', error);
+            throw error;
+        }
+    }
+
+    /**
+     *  
+     * @param userId Optional     
+     *  
+     * @returns Owner by default
+     */
+    public async getUser(userId?: string): Promise<User> {
+        const query = userId 
+            ? `
+                query User($userId: String!) {
+                    user(id: $userId) {
+                        user_id    
+                        name
+                        email
+                    }
+                }
+            `
+            : `
+                query {
+                    user {
+                        user_id
+                        name
+                        email
+                    }
+                }
+            `;
+
+        // Pass variables only if userId is defined
+        const response = userId
+            ? await this.executeQuery<{ user: User }>(query, { userId })
+            : await this.executeQuery<{ user: User }>(query);
+
+        return response.data.user;
+    }
+
+    // You can add more methods to handle other queries or mutations here
+}

src/providers/fireflies/index.ts

@@ -0,0 +1,85 @@
+import { Request, Response } from 'express'
+import Base from "../BaseProvider"
+
+import { BaseProviderConfig, ConnectionCallbackResponse, PassportProfile } from '../../interfaces'
+import { FireFliesClient, FireFliesConfig } from './api'
+import MeetingTranscriptHandler from './meeting-transcript'
+
+export default class FireFliesProvider extends Base {
+
+    protected config: BaseProviderConfig
+
+
+    public getProviderName() {
+        return 'fireflies'
+    }
+
+    public getProviderLabel() {
+        return 'FireFlies'
+    }
+
+    public getProviderApplicationUrl() {
+        return 'https://fireflies.ai/'
+    }
+
+    public setConfig(config: BaseProviderConfig) {
+        this.config = config
+    }
+
+    public syncHandlers(): any[] {
+        return [
+            MeetingTranscriptHandler
+        ]
+    }
+
+    public async connect(req: Request, res: Response, next: any): Promise<any> {
+        return res.redirect('/provider/fireflies')
+    }
+
+    public async callback(req: Request, res: Response, next: any): Promise<ConnectionCallbackResponse> {
+        const apiKey = req.query.apiKey!.toString();
+
+        // Initialize Fireflies client configuration
+        const config: FireFliesConfig = {
+            apiKey: apiKey
+        };
+
+        const client = new FireFliesClient(config);
+
+        // Fetch user profile from Fireflies
+        const ffProfile = await client.getUser();
+
+        // Set up display name
+        const displayName = ffProfile.name.trim();
+
+        // Construct the profile structure similar to the Telegram format
+        const profile: PassportProfile = {
+            id: ffProfile.user_id.toString(),
+            provider: this.getProviderId(), // Assuming getProviderId() returns 'fireflies' or similar identifier
+            displayName: displayName,
+            name: {
+                familyName: ffProfile.name.split(" ").slice(-1)[0], // Last word as family name
+                givenName: ffProfile.name.split(" ").slice(0, -1).join(" ") // First part as given name
+            },
+            connectionProfile: {
+                username: ffProfile.email.split('@')[0], // Username from email prefix
+                readableId: ffProfile.user_id,
+                email: ffProfile.email,
+                verified: true // Assuming profile is verified
+            }
+        };
+
+        return {
+            id: profile.id,
+            accessToken: apiKey,
+            refreshToken: apiKey,
+            profile
+        };
+    }
+
+    public async getApi(
+        accessToken?: string,
+        refreshToken?: string
+    ): Promise<any> { }
+}
+