@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v2/calendly/app/server/src/functions/ui.ts

@@ -0,0 +1,178 @@
+import { app, Cookie, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { childLogger } from '../lib/logging';
+
+import { appAccessTokenQueryParamName, coreApiAccessTokenQueryParamName, getAppAccessTokenCookieName, getCoreApiAccessTokenCookieName } from '@seeka-labs/sdk-apps-core';
+import { AppApiAuthInfo, getAccessTokenAndCheck } from '../lib/api/auth';
+import { deleteCalendlyAuth } from '../lib/api/routes/deleteCalendlyAuth';
+import { getCalendlyAuth } from '../lib/api/routes/getCalendlyAuth';
+import { setTrackingSettings } from '../lib/api/routes/setTrackingSettings';
+import { migrateAppState, SeekaAppInstallState } from '../lib/state/seeka/installations';
+
+// Define your route and handler for the /ui path
+app.http('ui', {
+    methods: ['GET', 'HEAD', 'POST', 'DELETE'],
+    authLevel: 'anonymous',
+    route: 'app/{*route}',  // Wildcard route under /ui
+    handler: ui
+});
+
+// Helper function to get the file content
+async function getFileContent(filePath: string, encoding?: BufferEncoding | undefined): Promise<string | Buffer> {
+    return await fs.readFile(filePath, { encoding: encoding });
+}
+
+const configJsFileName = 'config.js'
+
+// Function to serve the React app under /app
+export async function ui(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    let logger = childLogger({ requestId: context.invocationId, url: req.url });
+    logger.profile('http.seeka.webhook.app.ui')
+
+    const reqUrl = new URL(req.url);
+    const requestedPath = reqUrl.pathname?.replace(/^\/app/, '') || '/';
+    logger.verbose('Received Seeka ui request', { requestedPath, url: req.url });
+
+    const buildPath = path.resolve('./dist/src/ui/build');
+    // const buildPath = path.join(__dirname, 'build');)
+
+    let seekaAppId: string = null;
+    let seekaAppInstallId: string = null;
+    logger = childLogger({ requestId: context.invocationId, url: req.url, seekaAppInstallId });
+
+    let installation: SeekaAppInstallState | undefined;
+    const additionalHeaders = {};
+    let setCookies: Cookie[] = [];
+    let authResult: AppApiAuthInfo | undefined;
+
+    const checkAuth = async (): Promise<HttpResponseInit | null> => {
+        // Check auth
+        authResult = await getAccessTokenAndCheck(req, logger);
+        if (!authResult) {
+            return {
+                status: 403,
+                jsonBody: { error: 'Invalid token' }
+            };
+        }
+        seekaAppId = authResult.seekaAppId;
+        seekaAppInstallId = authResult.seekaAppInstallId;
+        installation = authResult.installation;
+
+        if (installation) {
+            installation = await migrateAppState(installation, logger);
+        }
+
+        setCookies.push({ name: getAppAccessTokenCookieName(process.env.SEEKA_APP_ID), value: authResult.appAccessToken, httpOnly: true, secure: true, sameSite: 'None', expires: new Date(authResult.expiresAt * 1000) });
+        setCookies.push({ name: getCoreApiAccessTokenCookieName(process.env.SEEKA_APP_ID), value: authResult.coreApiAccessToken, httpOnly: true, secure: true, sameSite: 'None', expires: new Date(authResult.expiresAt * 1000) });
+        return null;
+    }
+    let filePath = path.join(buildPath, requestedPath);
+
+    let content: string | Buffer;
+    try {
+        if (requestedPath === ('/' + configJsFileName)) {
+            const authRes = await checkAuth();
+            if (authRes) return authRes;
+
+            // const errResponse = checkRequiredUrlParams(reqUrl);
+            // if (errResponse) return errResponse;
+
+            // Under no means should internal or private api keys be exposed to the client with below 
+            const basePathUri = process.env['APP_UI_BASE_PATH'] ? `${process.env['APP_UI_BASE_PATH']}` : ''
+            const appBaseUrl = `${process.env.SELF_HOST_BASEURL}${basePathUri}`
+            const browserAppSettings = {
+                seekaAppId: seekaAppId,
+                seekaAppInstallId: seekaAppInstallId,
+                appBaseUrl,
+                calendlyClientId: process.env.CALENDLY_CLIENT_ID as string,
+                state: {
+                    tracking: installation?.installationState?.tracking,
+                    linkedCalendlyUser: installation?.installationState?.linkedCalendlyUser
+                }
+            };
+            content = `window.seekaAppConfig = ${JSON.stringify(browserAppSettings)}`
+        }
+
+        if (requestedPath.startsWith('/api')) {
+            const authRes = await checkAuth();
+            if (authRes) return authRes;
+
+            // Handle app api route
+            if (requestedPath === '/api/settings/calendly/tracking' && req.method === 'POST') return await setTrackingSettings(installation, req, context, logger);
+            if (requestedPath === '/api/settings/calendly/auth' && req.method === 'GET') return await getCalendlyAuth(installation, req, context, logger);
+            if (requestedPath === '/api/settings/calendly/auth' && req.method === 'DELETE') return await deleteCalendlyAuth(installation, req, context, logger);
+
+            return {
+                status: 404,
+                jsonBody: { error: 'Not found' }
+            };
+        }
+
+        if (requestedPath === '/' || requestedPath === '/index.html') {
+            const authRes = await checkAuth();
+            if (authRes) return authRes;
+
+            // const errResponse = checkRequiredUrlParams(reqUrl);
+            // if (errResponse) return errResponse;
+
+            // Serve index.html for the root or when accessing directly
+            const tokenParams = `?${appAccessTokenQueryParamName}=${encodeURIComponent(authResult.appAccessToken)}`
+                + `&${coreApiAccessTokenQueryParamName}=${encodeURIComponent(authResult.coreApiAccessToken)}&`;
+
+            filePath = path.join(buildPath, 'index.html');
+            let html = (await getFileContent(filePath, 'utf-8')) as string;
+            html = html.replace(configJsFileName + '?', configJsFileName + tokenParams);
+            content = html;
+        } else {
+            // Resolve the requested file path
+            filePath = path.join(buildPath, requestedPath);
+            // Ensure the file exists, otherwise fallback to index.html (for client-side routing)
+            await fs.access(filePath);
+        }
+    } catch (err) {
+        console.log('File not found, serving index.html', err);
+        filePath = path.join(buildPath, 'index.html');
+    }
+
+    if (!content) {
+        content = await getFileContent(filePath);
+    }
+
+    const contentType = getContentType(filePath);
+
+    return {
+        status: 200,
+        headers: {
+            'Content-Type': contentType,
+            'Referrer-Policy': 'no-referrer',
+            ...additionalHeaders
+        },
+        cookies: setCookies,
+        body: content,
+    };
+}
+
+// const checkRequiredUrlParams = (reqUrl: URL): any | undefined => {
+//     const seekaAppId = reqUrl.searchParams.get('seekaAppId');
+//     if (seekaAppId != process.env.SEEKA_APP_ID) {
+//         console.log('App ID invalid', { url: reqUrl, seekaAppId, seekaAppIdEnv: process.env.SEEKA_APP_ID });
+//         return {
+//             status: 422,
+//             jsonBody: { error: "App ID invalid" }
+//         }
+//     }
+
+//     return undefined;
+// }
+
+// Function to determine the content type based on file extension
+function getContentType(filePath: string): string {
+    if (filePath.endsWith('.html')) return 'text/html';
+    if (filePath.endsWith('.js')) return 'application/javascript';
+    if (filePath.endsWith('.css')) return 'text/css';
+    if (filePath.endsWith('.png')) return 'image/png';
+    if (filePath.endsWith('.jpg') || filePath.endsWith('.jpeg')) return 'image/jpeg';
+    if (filePath.endsWith('.gif')) return 'image/gif';
+    return 'application/octet-stream';
+}

package/dist/ai-context/internal/examples/v2/calendly/app/server/src/lib/api/auth.ts

@@ -0,0 +1,91 @@
+import { HttpRequest } from "@azure/functions";
+import { appAccessTokenHeaderName, appAccessTokenQueryParamName, coreApiAccessTokenHeaderName, coreApiAccessTokenQueryParamName, getAppAccessTokenCookieName, getCoreApiAccessTokenCookieName } from "@seeka-labs/sdk-apps-core";
+import jwt from 'jsonwebtoken';
+import { Logger } from "winston";
+import { startServices } from '../services';
+import { SeekaAppInstallState, tryGetInstallation } from "../state/seeka/installations";
+
+
+export const getAccessTokenAndCheck = async (req: HttpRequest, logger: Logger): Promise<AppApiAuthInfo | undefined> => {
+    const reqUrl = new URL(req.url);
+
+    // Get access token from cookie
+    const cookies = req.headers.get('Cookie');
+    // logger.info('Cookie', cookies);
+    let accessToken: string = reqUrl.searchParams.get(appAccessTokenQueryParamName) || '';
+    if (!accessToken && req.headers.get(appAccessTokenHeaderName)) {
+        accessToken = req.headers.get(appAccessTokenHeaderName)?.split('Bearer ')[1];
+    }
+    if (!accessToken && cookies) {
+        const cookie = cookies.split(';').find(c => c.trim().startsWith(getAppAccessTokenCookieName(process.env.SEEKA_APP_ID)));
+        if (cookie) {
+            accessToken = cookie.split('=')[1];
+        }
+    }
+
+    let coreApiAccessToken: string = reqUrl.searchParams.get(coreApiAccessTokenQueryParamName) || '';
+    if (!coreApiAccessToken && req.headers.get(coreApiAccessTokenHeaderName)) {
+        coreApiAccessToken = req.headers.get(coreApiAccessTokenHeaderName)?.split('Bearer ')[1];
+    }
+    if (!coreApiAccessToken && cookies) {
+        const cookie = cookies.split(';').find(c => c.trim().startsWith(getCoreApiAccessTokenCookieName(process.env.SEEKA_APP_ID)));
+        if (cookie) {
+            coreApiAccessToken = cookie.split('=')[1];
+        }
+    }
+
+    // Validate access token
+    return await checkAuth(accessToken, coreApiAccessToken, true, logger);
+}
+
+export const checkAuth = async (appAccessToken: string, coreApiAccessToken: string, startAppServices: boolean, logger: Logger): Promise<AppApiAuthInfo | undefined> => {
+    let seekaAppId: string;
+    let seekaAppInstallId;
+    let expiresAt: number;
+
+    // Validate access token
+    if (appAccessToken) {
+        try {
+            const decoded = jwt.verify(appAccessToken, process.env['SEEKA_APP_SECRET'] as string) as jwt.JwtPayload;
+            logger.info('Decoded token', { decoded });
+            if (!decoded.appId || decoded.appId.replace(/-/g, '') !== process.env['SEEKA_APP_ID'].replace(/-/g, '') as string) {
+                logger.error('Invalid token - app id does not match', { decoded, appIdToken: decoded.appId, appIdEnv: process.env['SEEKA_APP_ID'] });
+                return undefined;
+            }
+            else {
+                seekaAppId = decoded.appId;
+            }
+            if (!decoded.appInstallId) {
+                logger.error('Invalid token - no appInstallId', { decoded });
+                return undefined;
+            }
+            else {
+                seekaAppInstallId = decoded.appInstallId;
+            }
+
+            expiresAt = decoded.exp as number;
+        }
+        catch (err) {
+            logger.error('Failed to validate token', { err });
+            return undefined;
+        }
+    }
+    else {
+        logger.error('No access token present');
+        return undefined;
+    }
+
+    // Check if the webhook is for an app we have installed    
+    if (startAppServices) {
+        await startServices(logger);
+    }
+    const installation = await tryGetInstallation(seekaAppInstallId, false, logger);
+    if (installation == null) {
+        logger.warn('UI call cannot be processed as the installation ID is not known by this app', { seekaAppInstallId });
+        return undefined;
+    }
+
+    return { appAccessToken, coreApiAccessToken, seekaAppId, seekaAppInstallId, expiresAt, installation };
+}
+
+export interface AppApiAuthInfo { appAccessToken: string, coreApiAccessToken: string, seekaAppId: string, seekaAppInstallId: string, expiresAt: number, installation: SeekaAppInstallState }

package/dist/ai-context/internal/examples/v2/calendly/app/server/src/lib/api/routes/deleteCalendlyAuth.ts

@@ -0,0 +1,15 @@
+import { HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";
+import { Logger } from "winston";
+import { createOrUpdateInstallation, SeekaAppInstallState } from "../../state/seeka/installations";
+
+export const deleteCalendlyAuth = async (installation: SeekaAppInstallState, req: HttpRequest, context: InvocationContext, logger: Logger): Promise<HttpResponseInit> => {
+    installation.installationState = {
+        ...installation.installationState,
+        linkedCalendlyUser: null
+    };
+    await createOrUpdateInstallation(installation, logger);
+
+    return {
+        status: 200
+    };
+}

package/dist/ai-context/internal/examples/v2/calendly/app/server/src/lib/api/routes/getCalendlyAuth.ts

@@ -0,0 +1,12 @@
+import { HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";
+import { Logger } from "winston";
+import { SeekaAppInstallState } from "../../state/seeka/installations";
+
+export const getCalendlyAuth = async (installation: SeekaAppInstallState, req: HttpRequest, context: InvocationContext, logger: Logger): Promise<HttpResponseInit> => {
+    return {
+        jsonBody: {
+            linkedCalendlyUser: installation.installationState?.linkedCalendlyUser ? installation.installationState?.linkedCalendlyUser : null
+        },
+        status: 200
+    };
+}

package/dist/ai-context/internal/examples/v2/calendly/app/server/src/lib/api/routes/setTrackingSettings.ts

@@ -0,0 +1,26 @@
+import { HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";
+import { CalendlyTrackingSettings } from "@seeka-app-calendly/lib";
+import { Logger } from "winston";
+import { createOrUpdateInstallation, SeekaAppInstallState } from "../../state/seeka/installations";
+
+export const setTrackingSettings = async (installation: SeekaAppInstallState, req: HttpRequest, context: InvocationContext, logger: Logger): Promise<HttpResponseInit> => {
+    // Validate
+    const body = (await req.json()) as any;
+    const tracking = body as CalendlyTrackingSettings | undefined;
+    if (!tracking) {
+        return {
+            status: 400,
+            jsonBody: { error: 'body is required' }
+        };
+    }
+
+    installation.installationState = {
+        ...installation.installationState,
+        tracking
+    };
+    await createOrUpdateInstallation(installation, logger);
+
+    return {
+        status: 200
+    };
+}

package/dist/ai-context/internal/examples/v2/calendly/app/server/src/lib/browser/index.ts

@@ -0,0 +1,53 @@
+import type { ICalendlyBrowserSdkPluginConfig } from '@seeka-app-calendly/lib';
+import { SeekaBrowserSdkPluginWebhookResponse } from '@seeka-labs/sdk-apps-server';
+import fs from 'fs';
+import path from 'path';
+import util from 'util';
+import winston, { Logger } from 'winston';
+import {
+    SeekaAppInstallState
+} from '../state/seeka/installations';
+
+const fileExistsAsync = util.promisify(fs.exists);
+const readFileAsync = util.promisify(fs.readFile);
+
+export async function getSeekaBrowserPlugin(installation: SeekaAppInstallState, logger: Logger): Promise<SeekaBrowserSdkPluginWebhookResponse> {
+    logger.profile('http.seeka.browser.plugin')
+
+    let content: string | undefined;
+    let init: string | undefined;
+
+    try {
+        logger.verbose('Handling request for browser plugin content');
+        const browserPluginPath = path.resolve('./dist/src/browser/seeka-app-calendly.min.js');
+        if (await fileExistsAsync(browserPluginPath)) {
+            // Content of the script. This should not change per installation it should be the same for all installations            
+            content = await readFileAsync(browserPluginPath, 'utf8');
+
+            // Configuration for the plugin. This can be different per installation
+            const pluginConfig = {
+                tracking: installation.installationState?.tracking,
+                appId: process.env.SEEKA_APP_ID,
+                appInstallId: installation.applicationInstallId,
+                appUrl: process.env.SELF_HOST_BASEURL
+            } as ICalendlyBrowserSdkPluginConfig;
+            init = `CalendlyConvergeSdkPlugin(${JSON.stringify(pluginConfig)})`;
+        }
+        else {
+            logger.error('Browser plugin content not found', { path: browserPluginPath });
+        }
+    }
+    catch (err) {
+        logger.error('Failed to handle request for browser plugin content', { ex: winston.exceptions.getAllInfo(err) });
+    }
+    finally {
+        logger.profile('http.seeka.browser.plugin')
+        logger.verbose('Request for browser plugin content handled');
+    }
+
+    if (!content || !init) {
+        throw new Error('Failed to handle request for browser plugin content')
+    }
+
+    return { content, init: init }
+}

package/dist/ai-context/internal/examples/v2/calendly/app/server/src/lib/calendly/attendee.ts

@@ -0,0 +1,198 @@
+import { ActivityPayload, PersonIdentifiers, SeekaAppHelper, TrackingActivityNames, TrackingEventSourceOriginType, getActivityName, separatePersonFullName } from "@seeka-labs/sdk-apps-server";
+import { Logger } from "winston";
+import * as packageJson from '../../../package.json';
+import { SeekaAppInstallState } from "../state/seeka/installations";
+import { CalendlyAccessToken } from "./auth";
+
+export const handleAttendeeCreated = async (installation: SeekaAppInstallState, body: InviteeCreatedWebhookBody, logger: Logger): Promise<void> => {
+    const helper = SeekaAppHelper.create(process.env['SEEKA_APP_SECRET'] as string, {
+        organisationId: installation.organisationId as string,
+        applicationInstallId: installation.applicationInstallId as string,
+        applicationId: process.env['SEEKA_APP_ID'] as string,
+    }, { name: packageJson.name, version: packageJson.version }, installation.installationState.grantedPermissions, logger);
+
+    const profile = inviteeCreatedWebhookPayloadToSeekaProfile(body.payload);
+    const activity = inviteeCreatedWebhookPayloadToSeekaEvent(installation, body.payload);
+
+    await helper.api.trackActivityForProfile(activity, profile, {
+        origin: TrackingEventSourceOriginType.Server,
+    })
+}
+
+export const getInvitee = async (eventUuid: string, inviteeUuid: string, token: CalendlyAccessToken, logger: Logger): Promise<CalendlyInvitee> => {
+    const url = `https://api.calendly.com/scheduled_events/${eventUuid}/invitees/${inviteeUuid}`;
+
+    const options = {
+        method: 'GET',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Bearer ' + token.access_token
+        }
+    };
+    const res = await fetch(url, options);
+    if (res.status != 200) {
+        logger.error('Failed to get Calendly invitee', { status: res.status, body: res.text(), headers: res.headers });
+        throw new Error('Failed to get Calendly invitee');
+    }
+    const json = (await res.json())['resource'] as CalendlyInvitee;
+
+    return json;
+}
+
+const inviteeCreatedWebhookPayloadToSeekaEvent = (installation: SeekaAppInstallState, payload: CalendlyInvitee): ActivityPayload => {
+    const activity = {
+
+    } as ActivityPayload;
+
+    if (installation.installationState?.tracking?.eventBookedEventName?.inputValue) {
+        const eventName = getActivityName(installation.installationState?.tracking?.eventBookedEventName?.inputValue);
+        if (eventName === TrackingActivityNames.Custom) {
+            activity.activityNameCustom = installation.installationState?.tracking?.eventBookedEventName?.inputValue;
+            activity.activityName = TrackingActivityNames.Custom;
+        }
+        else {
+            activity.activityName = eventName;
+        }
+    }
+    else {
+        activity.activityName = TrackingActivityNames.Custom;
+        activity.activityNameCustom = 'CalendlyInviteCreated';
+    }
+
+    // if(payload.tracking){
+    //     if(payload.tracking.utm_campaign) 
+    // }
+
+    const eventId = payload.event.split('/').splice(-1)[0];
+    const attendeeId = payload.uri.split('/').splice(-1)[0];
+    const eventName = payload.scheduled_event?.name;
+    switch (activity.activityName) {
+        case TrackingActivityNames.Lead: {
+            activity.lead = {
+                sourceContentName: eventName
+            }
+            break;
+        }
+        case TrackingActivityNames.Custom:
+        case TrackingActivityNames.Schedule: {
+            activity.contentItem = {
+                contentName: eventName,
+                identifiers: [eventId]
+            }
+            break;
+        }
+    }
+
+    activity.activityId = `calendly_${eventId}_invite_${attendeeId}_created`
+
+    return activity;
+}
+
+export const inviteeCreatedWebhookPayloadToSeekaProfile = (payload: CalendlyInvitee): PersonIdentifiers => {
+    const inviteeId = payload.uri.split('/').splice(-1)[0];
+    const profile = {
+        calendly: {
+            inviteeId: [inviteeId]
+        }
+    } as PersonIdentifiers;
+
+    if (payload.email) {
+        profile.email = [payload.email];
+    }
+
+    if (!payload.first_name && !payload.last_name && payload.name) {
+        const name = separatePersonFullName(payload.name);
+        profile.firstName = [name.firstName];
+        profile.lastName = [name.lastName];
+    }
+    else {
+        profile.firstName = payload.name ? [payload.name] : (payload.first_name ? [payload.first_name] : []);
+        if (payload.last_name) profile.lastName = [payload.last_name];
+    }
+
+    return profile;
+}
+
+export interface InviteeCreatedWebhookBody {
+    created_at: string
+    created_by: string
+    event: 'invitee.created'
+    payload: CalendlyInvitee
+}
+
+export interface CalendlyInvitee {
+    cancel_url: string
+    created_at: string
+    email: string
+    event: string
+    first_name: string
+    invitee_scheduled_by: string
+    last_name: string
+    name: string
+    // new_invitee: any
+    // no_show: any
+    // old_invitee: any
+    // payment: any
+    questions_and_answers: QuestionsAndAnswer[]
+    // reconfirmation: any
+    reschedule_url: string
+    rescheduled: boolean
+    // routing_form_submission: any
+    scheduled_event: ScheduledEvent
+    // scheduling_method: any
+    status: string
+    // text_reminder_number: any
+    timezone: string
+    tracking: Tracking
+    updated_at: string
+    uri: string
+}
+
+export interface QuestionsAndAnswer {
+    answer: string
+    position: number
+    question: string
+}
+
+export interface ScheduledEvent {
+    created_at: string
+    end_time: string
+    // event_guests: any[]
+    event_memberships: EventMembership[]
+    event_type: string
+    invitees_counter: InviteesCounter
+    location: Location
+    meeting_notes_html: string
+    meeting_notes_plain: string
+    name: string
+    start_time: string
+    status: string
+    updated_at: string
+    uri: string
+}
+
+export interface EventMembership {
+    user: string
+    user_email: string
+    user_name: string
+}
+
+export interface InviteesCounter {
+    active: number
+    limit: number
+    total: number
+}
+
+export interface Location {
+    // location: any
+    type: string
+}
+
+export interface Tracking {
+    salesforce_uuid: string
+    utm_campaign: string
+    utm_content: string
+    utm_medium: string
+    utm_source: string
+    utm_term: string
+}

package/dist/ai-context/internal/examples/v2/calendly/app/server/src/lib/calendly/auth.ts

@@ -0,0 +1,103 @@
+import fetch from 'node-fetch';
+import { Logger } from "winston";
+import { SeekaAppInstallState, createOrUpdateInstallation } from "../state/seeka/installations";
+
+export const handleCalendlyAuthCallback = async (installation: SeekaAppInstallState, oAuthCode: string, redirectUri: string, logger: Logger): Promise<SeekaAppInstallState> => {
+    // let installation: SeekaAppInstallState | null = null;
+    // installation = await tryGetInstallation(seekaAppInstallId as string, false, logger);
+    // if (installation == null) {
+    //     logger.error('Webhook call cannot be processed as the installation ID is not known by this app', { seekaAppInstallId });
+
+    //     throw new Error('App not installed');
+    // }
+
+    const token = await getInitialCalendlyOAuthToken(oAuthCode, redirectUri, logger);
+
+    installation.installationState.calendlyToken = JSON.stringify(token);
+    installation.installationState.linkedCalendlyUser = {
+        organisation: token.organization,
+        owner: token.owner
+    }
+    return await createOrUpdateInstallation(installation, logger);
+}
+
+const getInitialCalendlyOAuthToken = async (oAuthCode: string, redirectUri: string, logger: Logger): Promise<CalendlyAccessToken> => {
+    // https://developer.calendly.com/api-docs/be9b32ef4b44c-get-access-token
+    const encodedParams = new URLSearchParams();
+
+    const url = `https://auth.calendly.com/oauth/token`;
+    encodedParams.set('grant_type', 'authorization_code');
+    encodedParams.set('code', oAuthCode);
+    encodedParams.set('redirect_uri', redirectUri);
+
+    const options = {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Authorization: 'Basic ' + Buffer.from(`${process.env.CALENDLY_CLIENT_ID}:${process.env.CALENDLY_CLIENT_SECRET}`).toString('base64')
+        },
+        body: encodedParams.toString()
+    };
+
+    const res = await fetch(url, options);
+    const json = await res.json();
+    if (!json.access_token || !json.refresh_token) {
+        logger.error('Failed to get Calendly OAuth token', { json });
+        throw new Error('Failed to get Calendly OAuth token');
+    }
+
+    return json as CalendlyAccessToken;
+}
+
+export const getCalendlyAccessToken = async (installation: SeekaAppInstallState, logger: Logger): Promise<CalendlyAccessToken> => {
+    let token = JSON.parse(installation.installationState.calendlyToken) as CalendlyAccessToken;
+    if (token.expires_in < Date.now() - token.created_at) {
+        token = await refreshCalendlyAccessToken(token.refresh_token, logger);
+        installation.installationState.calendlyToken = JSON.stringify(token);
+
+        await createOrUpdateInstallation(installation, logger);
+    }
+
+    return token;
+}
+
+const refreshCalendlyAccessToken = async (refreshToken: string, logger: Logger): Promise<CalendlyAccessToken> => {
+    // https://developer.calendly.com/api-docs/be9b32ef4b44c-get-access-token
+    const encodedParams = new URLSearchParams();
+
+    const url = `https://auth.calendly.com/oauth/token`;
+    encodedParams.set('grant_type', 'refresh_token');
+    encodedParams.set('refresh_token', refreshToken);
+
+    const options = {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Authorization: 'Basic ' + Buffer.from(`${process.env.CALENDLY_CLIENT_ID}:${process.env.CALENDLY_CLIENT_SECRET}`).toString('base64')
+        },
+        body: encodedParams.toString()
+    };
+
+    const res = await fetch(url, options);
+    const json = await res.json();
+    if (!json || !json.access_token || !json.refresh_token) {
+        logger.error('Failed to refresh Calendly OAuth token', { json });
+        throw new Error('Failed to refresh Calendly OAuth token');
+    }
+    else {
+        logger.info('Successfully refreshed Calendly OAuth token');
+    }
+
+    return json as CalendlyAccessToken;
+}
+
+export interface CalendlyAccessToken {
+    token_type: string
+    expires_in: number
+    created_at: number
+    refresh_token: string
+    access_token: string
+    scope: string
+    owner: string
+    organization: string
+}