@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v2/typeform/app/server/src/functions/typeformWebhook.ts

@@ -0,0 +1,109 @@
+import * as winston from 'winston';
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+import { childLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import {
+    tryGetInstallation
+} from '../lib/state/seeka/installations';
+import { throwOnInvalidTypeformWebhook } from '../lib/typeform/webhooks';
+
+import { handleTypeformFormResponseWebhook } from '../lib/typeform/forms';
+
+import { SeekaAppHelper } from '@seeka-labs/sdk-apps-server';
+import { TypeformWebhookBody } from '../lib/typeform/models';
+
+import { name, version } from '../../package.json';
+
+app.http('typeformWebhook', {
+    methods: ['POST'],
+    authLevel: 'anonymous',
+    route: 'api/webhook/typeform',
+    handler: typeformWebhook
+});
+
+export async function typeformWebhook(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    const bodyStr = (await req.text()) as string;
+    const body: TypeformWebhookBody = JSON.parse(bodyStr);
+
+    let logger = childLogger({ requestId: context.invocationId, url: req.url });
+
+    logger.profile('http.typeform.webhook')
+    logger.verbose('Received webhook from Typeform', { body });
+
+    // Validate webhook
+    try {
+        const typeformSignature = req.headers.get('Typeform-Signature');
+        throwOnInvalidTypeformWebhook(typeformSignature, bodyStr);
+        logger.debug('Webhook signature validated', { body });
+    }
+    catch {
+        logger.warn('Webhook signature invalid', { body });
+        return {
+            status: 401,
+            jsonBody: { error: "Webhook call invalid" }
+        }
+    }
+
+    const reqUrl = new URL(req.url);
+    const seekaAppId = reqUrl.searchParams.get('seekaAppId');
+    const seekaAppInstallId = reqUrl.searchParams.get('seekaAppInstallId');
+    logger = childLogger({ requestId: context.invocationId, url: req.url, seekaAppInstallId });
+    if (seekaAppId != process.env.SEEKA_APP_ID) {
+        return {
+            status: 422,
+            jsonBody: { error: "App ID invalid" }
+        }
+    }
+
+    await startServices(logger);
+
+    // Check if the webhook is for an app we have installed
+    const installation = await tryGetInstallation(seekaAppInstallId as string, false, logger);
+    if (installation == null) {
+        logger.warn('Webhook call cannot be processed as the installation ID is not known by this app', { body });
+
+        return {
+            status: 422,
+            jsonBody: { error: "App not installed" }
+        }
+    }
+    logger = childLogger(null, installation, logger);
+
+    try {
+        logger.verbose('Handling Typeform webhook', { body });
+        switch (body.event_type) {
+            case 'form_response':
+            case 'form_response_partial':
+                {
+                    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, version }, installation.installationState.grantedPermissions, logger);
+
+                    logger.info(`Handling Typeform ${body.event_type} webhook`, { body });
+                    await handleTypeformFormResponseWebhook(body, helper, installation, logger);
+                    break;
+                }
+            default:
+                logger.warn('Unhandled Typeform webhook event type', { event: body.event_type });
+        }
+    }
+    catch (err) {
+        logger.error('Failed to handle Typeform webhook', { ex: winston.exceptions.getAllInfo(err) });
+        return {
+            status: 500,
+            jsonBody: { error: "Request failed" }
+        }
+    }
+    finally {
+        logger.profile('http.typeform.webhook')
+        logger.verbose('Typeform webhook handled');
+    }
+
+    return {
+        status: 204
+    }
+}

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

@@ -0,0 +1,182 @@
+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 { SeekaAppInstallState } from '../lib/state/seeka/installations';
+
+import { AppApiAuthInfo, getAccessTokenAndCheck } from '../lib/api/auth';
+
+import { disconnectTypeform } from '../lib/api/routes/disconnectTypeform';
+import { getTypeformAuthInfo } from '../lib/api/routes/getTypeformAuthInfo';
+import { setFormBindings } from '../lib/api/routes/setFormBindings';
+
+// 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, method: req.method });
+
+    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;
+
+        logger = childLogger(null, 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 creds = JSON.parse(process.env.GOOGLE_CLOUD_SERVICEACCOUNT_CREDS_JSON as string);
+            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,
+                organisationBrandId: installation?.organisationBrandId,
+                appBaseUrl,
+                state: {
+                    hasUserAccessToken: Boolean(installation?.installationState?.typeformAccessToken),
+                    formBindings: installation?.installationState?.formBindings || []
+                }
+            };
+            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/typeform/auth' && req.method === 'DELETE') return await disconnectTypeform(installation, req, context, logger);
+            if (requestedPath === '/api/typeform/auth' && req.method === 'GET') return await getTypeformAuthInfo(installation, req, context, logger);
+            if (requestedPath === '/api/settings/form-bindings' && req.method === 'POST') return await setFormBindings(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) {
+        // logger.error('Error trying to serve content', { ex: winston.exceptions.getAllInfo(err), requestedPath });
+        // console.log('File not found, serving index.html', err);
+        // filePath = path.join(buildPath, 'index.html');
+        filePath = path.join(buildPath, 'index.html');
+        console.log('File not found, serving index.html', { err, requestedPath, buildPath, filePath, content });
+    }
+
+    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/typeform/app/server/src/index.test.ts

@@ -0,0 +1,7 @@
+import { describe, expect, test } from '@jest/globals';
+
+describe('test example module', () => {
+    test('should be false', () => {
+        expect(false).toBeFalsy();
+    });
+});

package/dist/ai-context/internal/examples/v2/typeform/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, { ignoreNotBefore: true }) 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/typeform/app/server/src/lib/api/routes/disconnectTypeform.ts

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

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

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

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

@@ -0,0 +1,43 @@
+import { HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";
+import { TypeformFormBinding } from "@seeka-app-typeform/lib";
+import { Logger } from "winston";
+import { createOrUpdateInstallation, SeekaAppInstallState } from "../../state/seeka/installations";
+import { maintainWebhooks } from "../../typeform/webhooks";
+
+export const setFormBindings = async (installation: SeekaAppInstallState, req: HttpRequest, context: InvocationContext, logger: Logger): Promise<HttpResponseInit> => {
+    // Validate
+    const body = (await req.json()) as any;
+    const bindings = body.bindings as TypeformFormBinding[] | undefined;
+    if (!bindings) {
+        return {
+            status: 400,
+            jsonBody: { error: 'bindings is required' }
+        };
+    }
+
+    // TODO: valiodation from shared lib
+    // try {
+    //     GoogleConversionMappingFormSchema.validateSync({ mappings }, { abortEarly: false });
+    // }
+    // catch (err) {
+    //     const validationError = (err as ValidationError)
+    //     if (validationError.inner) {
+    //         return {
+    //             status: 400,
+    //             jsonBody: { errors: validationError.inner }
+    //         };
+    //     }
+    // }
+
+    installation.installationState = {
+        ...installation.installationState,
+        formBindings: bindings || []
+    };
+    installation = await createOrUpdateInstallation(installation, logger);
+
+    await maintainWebhooks(installation, false, logger);
+
+    return {
+        status: 200
+    };
+}

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

@@ -0,0 +1,52 @@
+import { ITypeformAppBrowserSdkPluginConfig } from '@seeka-app-typeform/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-typeform.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 = {
+                appId: process.env.SEEKA_APP_ID,
+                appInstallId: installation.applicationInstallId,
+                appUrl: process.env.SELF_HOST_BASEURL
+            } as ITypeformAppBrowserSdkPluginConfig;
+            init = `TypeformAppConvergeSdkPlugin(${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/typeform/app/server/src/lib/logging/index.ts

@@ -0,0 +1,89 @@
+import * as winston from 'winston';
+
+import { InvocationContext } from '@azure/functions';
+import { SeqTransport } from '@datalust/winston-seq';
+
+import * as packageJson from '../../../package.json';
+
+import type {
+    SeekaWebhookPayload, SeekaWebhookPayloadOfSeekaAppWebhookContext
+} from '@seeka-labs/sdk-apps-server';
+import { SeekaAppInstallState } from '../state/seeka/installations';
+
+const loggerTransports: winston.transport[] = [
+    new winston.transports.Console({
+        level: process.env.LOGGING_LEVEL,
+        format: winston.format.combine(
+            winston.format.errors({ stack: true }),
+            winston.format.cli(),
+            winston.format.splat(),
+        ),
+        handleExceptions: true,
+        handleRejections: true,
+    }),
+]
+if (process.env.LOGGING_SEQ_SERVERURL) {
+    loggerTransports.push(
+        new SeqTransport({
+            level: process.env.LOGGING_LEVEL,
+            serverUrl: process.env.LOGGING_SEQ_SERVERURL,
+            apiKey: process.env.LOGGING_SEQ_APIKEY,
+            onError: ((e) => { console.error('Failed to configure Seq logging transport', e) }),
+            format: winston.format.combine(
+                winston.format.errors({ stack: true }),
+                winston.format.json(),
+            ),
+            handleExceptions: true,
+            handleRejections: true,
+        })
+    )
+}
+
+const defaultMeta = {
+    seekaAppId: process.env.SEEKA_APP_ID,
+    Hosting_Provider: 'azure',
+    Release_Version: `v${packageJson.version.split('-')[0]}`,
+    Hosting_Region: process.env.REGION_NAME,
+    Service_Instance_Id: process.env.WEBSITE_ROLE_INSTANCE_ID,
+    AzureFunctions_FunctionName: process.env.WEBSITE_SITE_NAME,
+    Service: `app/${packageJson.name}`,
+};
+
+export const logger = winston.createLogger({
+    level: process.env.LOGGING_LEVEL,
+    defaultMeta: {
+        ...defaultMeta
+    },
+    transports: loggerTransports,
+    exitOnError: false,
+});
+
+export const childLogger = (meta: object | null, installation?: SeekaAppInstallState, l: winston.Logger = logger) => l.child({
+    ...defaultMeta, ...meta, ...(installation ? {
+        seekaAppInstallId: installation.applicationInstallId,
+        seekaAppInstallOrganisationBrandId: installation.organisationBrandId,
+        seekaAppInstallOrganisationId: installation.organisationId
+    } : {})
+});
+
+export const webhookLogger = (payload: SeekaWebhookPayload, functionContext: InvocationContext) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const meta: any = {
+        ...defaultMeta,
+        seekaWebhookType: payload.type,
+        seekaWebhookIsTest: payload.isTest,
+        RequestId: payload.requestId,
+        AzureFunctions_InvocationId: functionContext.invocationId,
+        CausationId: payload.causationId,
+        CorrelationId: payload.causationId,
+    }
+
+    const context = (payload as SeekaWebhookPayloadOfSeekaAppWebhookContext).context;
+    if (context) {
+        meta.seekaAppInstallId = context.applicationInstallId;
+        meta.seekaAppInstallOrganisationBrandId = context.organisationBrandId;
+        meta.seekaAppInstallOrganisationId = context.organisationId;
+    }
+
+    return childLogger(meta)
+}

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

@@ -0,0 +1,41 @@
+import winston, { Logger } from 'winston';
+
+import { connect, disconnect, isConnected } from '../state/redis';
+
+export const startServices = async (logger: Logger) => {
+    logger.debug(`Trying to connect to Redis - ${process.env.REDIS_CONNECTION_HOST}`)
+    try {
+        if (isConnected()) {
+            logger.verbose(`Redis already connected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+        else {
+            logger.profile('service.redis.connect')
+            await connect();
+            logger.profile('service.redis.connect')
+            logger.debug(`Redis connected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+    }
+    catch (err) {
+        logger.error(`Failed to connect to Redis - ${process.env.REDIS_CONNECTION_HOST}`, { ex: winston.exceptions.getAllInfo(err) })
+        throw err;
+    }
+}
+
+export const stopServices = async (logger: Logger) => {
+    logger.debug(`Trying to disconnect from Redis - ${process.env.REDIS_CONNECTION_HOST}`)
+    try {
+        if (isConnected() === false) {
+            logger.verbose(`Redis already disconnected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+        else {
+            logger.profile('service.redis.disconnect')
+            await disconnect();
+            logger.profile('service.redis.disconnect')
+            logger.verbose(`Redis disconnected - ${process.env.REDIS_CONNECTION_HOST}`)
+        }
+    }
+    catch (err) {
+        logger.error(`Failed to disconnect from Redis - ${process.env.REDIS_CONNECTION_HOST}`, { ex: winston.exceptions.getAllInfo(err) })
+        throw err;
+    }
+}