@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v1/ivvy/src/routes/seekaAppWebhook.ts

@@ -0,0 +1,141 @@
+import type { Logger } from 'winston';
+
+import {
+    SeekaAppInstalledWebhookPayload,
+    SeekaAppInstallSettingsUpdatedWebhookPayload, SeekaAppUninstalledWebhookPayload,
+    SeekaWebhookCallType, SeekaWebhookPayload,
+    throwOnInvalidWebhookSignature
+} from '@seeka-labs/sdk-apps-server';
+
+import { closeLogger, webhookLogger } from '../lib/logging';
+import { createOrUpdateInstallation, deleteInstallation, SeekaAppInstallState, tryGetInstallation } from '../lib/state/seeka/installations';
+import { startServices } from '../lib/services';
+import { Context } from 'aws-lambda';
+import { Request, Response } from 'express';
+
+import { ensureWebhooksSubscribed, unsubscribeFromWebhooks } from '../lib/ivvy/api/webhooks'
+import winston from 'winston';
+
+export async function seekaAppWebhook(req: Request, res: Response, context: Context): Promise<void> {
+    const bodyStr = req.body as string;
+    const body = JSON.parse(bodyStr) as SeekaWebhookPayload;
+
+    const logger = webhookLogger(body, context);
+    logger.profile('http.seeka.webhook.app')
+
+    if (process.env.SEEKA_DEBUG_ENABLED === 'true') {
+        logger.verbose('Received webhook from Seeka', { body });
+    }
+    else {
+        logger.verbose('Received webhook from Seeka');
+    }
+
+    // Handle probe 
+    if (body.type === SeekaWebhookCallType.Probe) {
+        await closeLogger();
+        res.status(204).send();
+        return;
+    }
+
+    // Validate webhook
+    try {
+        throwOnInvalidWebhookSignature(process.env.SEEKA_APP_SECRET as string, req.headers, bodyStr);
+        logger.debug('Webhook signature validated');
+    }
+    catch {
+        logger.warn('Webhook signature invalid', { body });
+        await closeLogger();
+        res.status(401).json({ error: "Webhook call invalid" }).send();
+        return;
+    }
+
+    if (body.isTest) {
+        // This is a test webhook call
+        await closeLogger();
+        res.status(204).send();
+        return;
+    }
+
+    await startServices(logger);
+
+    // Check if the webhook is for an app we have installed
+    let installation: SeekaAppInstallState | null = null;
+    if (body.type != SeekaWebhookCallType.AppInstalled) {
+        installation = await tryGetInstallation((body as SeekaAppInstalledWebhookPayload).context?.applicationInstallId as string, false, logger);
+        if (installation == null) {
+            logger.warn('Webhook call cannot be processed as the installation ID is not known by this app');
+
+            await closeLogger();
+            res.status(422).json({ error: "App not installed" }).send();
+            return;
+        }
+    }
+
+    try {
+        switch (body.type) {
+            case SeekaWebhookCallType.AppInstalled:
+                {
+                    await onInstallation(body as SeekaAppInstalledWebhookPayload, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppInstallSettingsUpdated:
+                {
+                    await onInstallationSettingsUpdate(body as SeekaAppInstallSettingsUpdatedWebhookPayload, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppUninstalled:
+                {
+                    const payload = body as SeekaAppUninstalledWebhookPayload;
+
+                    await unsubscribeFromWebhooks(installation as SeekaAppInstallState, logger);
+                    await deleteInstallation(payload.context?.applicationInstallId as string, logger)
+                    break;
+                }
+        }
+
+        logger.profile('http.seeka.webhook.app')
+        logger.verbose('Seeka webhook handled');
+        await closeLogger();
+        res.status(204).send();
+    }
+    catch (err) {
+        logger.error('Failed to handle webhook', { ex: winston.exceptions.getAllInfo(err) });
+
+        logger.profile('http.seeka.webhook.app')
+        logger.verbose('Seeka webhook handled');
+        await closeLogger();
+
+        res.status(500).json({ error: "Request failed" }).send();
+    }
+}
+
+const onInstallation = async (payload: SeekaAppInstalledWebhookPayload, logger: Logger) => {
+    const installation = await createOrUpdateInstallation({
+        ...payload.context,
+        applicationInstallId: payload.context?.applicationInstallId as string,
+        organisationBrandId: payload.context?.organisationBrandId as string,
+        organisationId: payload.context?.organisationId as string,
+        installationState: {
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        installedAt: new Date().toISOString(),
+        installationSettings: payload.content?.installationSettings || {}
+    }, logger)
+
+    await ensureWebhooksSubscribed(installation, logger);
+}
+
+const onInstallationSettingsUpdate = async (payload: SeekaAppInstallSettingsUpdatedWebhookPayload, logger: Logger) => {
+    let existingInstallation = await tryGetInstallation(payload.context?.applicationInstallId as string, true, logger) as SeekaAppInstallState;
+    existingInstallation = await createOrUpdateInstallation({
+        ...existingInstallation,
+        installationState: {
+            ...existingInstallation.installationState,
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        installationSettings: payload.content?.installationSettings || {},
+    }, logger)
+
+    // TODO: Remove below
+    await ensureWebhooksSubscribed(existingInstallation, logger);
+}

package/dist/ai-context/internal/examples/v1/ivvy/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "compilerOptions": {
+    "allowJs": false,
+    "skipLibCheck": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "preserveConstEnums": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "target": "es6",
+    "sourceMap": true,
+    "inlineSourceMap": false,
+    "resolveJsonModule": true,
+    "isolatedModules": false,
+    "forceConsistentCasingInFileNames": true,
+    "typeRoots": [
+      "node_modules/@types"
+    ],
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "src/index.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "scripts"
+  ]
+}

package/dist/ai-context/internal/examples/v1/me-and-u-connect/.eslintrc.cjs

@@ -0,0 +1,11 @@
+/* eslint-env node */
+module.exports = {
+    extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
+    parser: '@typescript-eslint/parser',
+    plugins: ['@typescript-eslint'],
+    root: true,
+    rules: {
+        "@typescript-eslint/no-unused-vars": "warn",
+        "@typescript-eslint/no-explicit-any": "warn",
+    }
+};

package/dist/ai-context/internal/examples/v1/me-and-u-connect/README.md

@@ -0,0 +1,66 @@
+# Seeka app - Me&u - connect / CRM
+
+## Development
+
+- See [Configure your environment](https://learn.microsoft.com/en-us/azure/azure-functions/create-first-function-vs-code-typescript?pivots=nodejs-model-v4#configure-your-environment) for dependencies
+- For emulating Azure storage queues, blobs and tables: `docker run --name azurite -p 10000:10000 -p 10001:10001 -p 10002:10002 --detach mcr.microsoft.com/azure-storage/azurite`
+- Set `AzureWebJobsStorage` setting in local.settings.json to `UseDevelopmentStorage=true`
+    - If not using WSL: 
+    `UseDevelopmentStorage=true`
+    - If using WSL: Ensure to replace DAN-LAPTOP with your hostname. Below connection string allows running Azurite on your host machine and lets WSL connect to it
+    `DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://DAN-LAPTOP.local:10000/devstoreaccount1;QueueEndpoint=http://DAN-LAPTOP.local:10001/devstoreaccount1;TableEndpoint=http://DAN-LAPTOP.local:10002/devstoreaccount1;`
+- Install Azure Storage explorer and create your queues (see `./src/lib/jobs/index.ts` for `queueNames`). Azure Storage explorer can be used to view your queue items.
+- `yarn install`
+- `yarn start`
+
+### Debugging
+Supports VSCode debugging via the debugger and utilisation of breakpoints. 
+This is only tested on Linux but may work on Windows. 
+If using Windows then use WSL with an Ubuntu distro for support of attaching the VS code debugger
+
+#### Live urls
+You can expose your app locally to the internet via Ngrok to test your app before deploying.
+
+##### Setup
+1. Sign up for a Ngrok account
+2. Get your auth token
+3. `yarn ngrok config add-authtoken [auth token here]` replacing `[auth token]` with the auth token retrieved from your Ngrok dashboard
+
+##### Running
+1. `yarn start` OR start debugging in VSCode
+2. In separate terminal window run `yarn tunnel` and observe the log entry that starts with `Live url exposed` for your Seeka app webhook URL that you can place in your Seeka app configuration.
+
+##### Invoking functions
+###### Development environment
+Scheduled / timer function: `curl -i -d '{"input": null}' -H "Content-Type: application/json" -X POST http://localhost:7072/admin/functions/meanduContactPolling`
+
+###### Azure cloud
+Scheduled / timer function: `curl -i -d '{"input": null}' -H "Content-Type: application/json" -H "x-functions-key: <key from azure portal>" -X POST https://seeka-app-meandu-connect.azurewebsites.net/admin/functions/meanduContactPolling`
+
+See [this doc](https://learn.microsoft.com/en-us/azure/azure-functions/functions-manually-run-non-http?tabs=azure-portal#get-the-master-key) on how to get the functions (master) key
+
+### Logging
+
+Winston included - TODO
+Seq included - TODO
+
+## Deployment
+This project comes ready to deploy for free to Azure functions with database backed by Redis hosted by Upstash and queues, blobs and tables backed by Azure Storage.
+
+At the point of writing, Netlify and Upstash can be used to deploy your app for free.
+- https://upstash.com/pricing
+- https://www.netlify.com/pricing/
+
+### Azure Function deploy
+- `yarn deploy`
+
+## State management
+Installations and other state is stored in Redis. Another state provider can be used, see `src/lib/state/seeka/installations.ts` for the file that manages the state of the installations.
+
+### Upstash (optional)
+If you dont want to use Upstash for Redis then swap out the connection strings with your Redis instance. 
+- When choosing region - use US East (Ohio) - us-east-* as this is the same Azure region that the Azure functions run from
+
+## References
+- https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azurite
+- https://learn.microsoft.com/en-us/azure/storage/queues/storage-quickstart-queues-nodejs?tabs=connection-string%2Croles-azure-portal%2Cenvironment-variable-windows%2Csign-in-azure-cli

package/dist/ai-context/internal/examples/v1/me-and-u-connect/_ai-summary.md

@@ -0,0 +1,29 @@
+# AI Summary for Me&u Connect App
+
+## Purpose and Functionality
+The "Me&u Connect" app is designed for integration with mobile ordering and payment tracking systems in the hospitality industry. It facilitates seamless interactions between restaurant services and customer management systems, enabling efficient order processing and payment tracking.
+
+## Key Implementation Patterns
+- **Azure Functions**: The app is built using Azure Functions, allowing for serverless execution of code in response to events such as HTTP requests and queue messages.
+- **Event-Driven Architecture**: Utilizes webhooks and storage queues to handle asynchronous events and background jobs, ensuring scalable and responsive operations.
+- **State Management**: Employs Redis for managing application state, particularly for installation data, which can be swapped with other state providers if needed.
+
+## External APIs/Services Integrated
+- **Azure Storage**: Used for queue management, enabling the app to handle background tasks and inter-process communication.
+- **Redis (Upstash)**: Provides a cloud-based Redis instance for state management, particularly for storing installation states.
+- **Ngrok**: Facilitates local development by exposing the app to the internet, allowing for testing of webhooks and remote interactions.
+
+## Important Data Transformations
+- **Webhook Payload Processing**: The app processes various types of webhook payloads, such as installation, uninstallation, and identity changes, transforming them into actionable tasks within the system.
+- **Queue Message Handling**: Transforms incoming queue messages into structured tasks, grouping them by application installation IDs for efficient processing.
+
+## Notable Code Patterns
+- **Webhook Signature Validation**: Implements a robust mechanism to validate webhook signatures, ensuring secure and authenticated communications.
+- **Background Job Scheduling**: Uses Azure Timer triggers to schedule periodic background jobs, such as contact synchronization, optimizing resource usage and maintaining system performance.
+- **Error Handling and Logging**: Utilizes Winston for structured logging and error handling, providing detailed insights into application behavior and facilitating debugging.
+
+## Deployment and Development
+- **Deployment**: The app is configured for deployment on Azure Functions, with support for free hosting options via Netlify and Upstash.
+- **Local Development**: Supports local development with Docker for emulating Azure Storage and Ngrok for testing webhooks, alongside a comprehensive setup for VSCode debugging.
+
+This summary provides an overview of the Me&u Connect app's architecture, integrations, and key functionalities, serving as a reference for AI assistants to understand and interact with the app effectively.

package/dist/ai-context/internal/examples/v1/me-and-u-connect/host.json

@@ -0,0 +1,20 @@
+{
+  "version": "2.0",
+  "logging": {
+    "applicationInsights": {
+      "samplingSettings": {
+        "isEnabled": true,
+        "excludedTypes": "Request"
+      }
+    }
+  },
+  "functionTimeout": "00:10:00",
+  "extensionBundle": {
+    "id": "Microsoft.Azure.Functions.ExtensionBundle",
+    "version": "[4.*, 5.0.0)"
+  },
+  "concurrency": {
+    "dynamicConcurrencyEnabled": true,
+    "snapshotPersistenceEnabled": true
+  }
+}

package/dist/ai-context/internal/examples/v1/me-and-u-connect/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "seeka-app-meandu-connect",
+  "version": "1.0.5",
+  "description": "Seeka app for Me&u connect CRM",
+  "repository": "https://gitlab.com/seeka-labs/app/apps/me-and-u-connect.git",
+  "author": "Seeka <platform@seeka.co>",
+  "license": "MIT",
+  "main": "dist/src/functions/*.js",
+  "private": true,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "lint": "eslint",
+    "build": "tsc",
+    "watch": "tsc -w",
+    "clean": "rimraf dist",
+    "prestart": "yarn run clean && yarn run build",
+    "start": "func start --port 7072",
+    "tunnel": "node scripts/ngrok.js seeka-app-me-and-u-connect-localdev",
+    "deploy": "yarn run clean && yarn run build && func azure functionapp publish seeka-app-meandu-connect --no-build --slot staging"
+  },
+  "dependencies": {
+    "@azure/functions": "^4.6.1",
+    "@azure/storage-queue": "^12.25.0",
+    "@datalust/winston-seq": "^2.0.0",
+    "@seeka-labs/sdk-apps-server": "^1.1.29",
+    "axios": "^1.7.9",
+    "fetch-retry": "^6.0.0",
+    "lodash": "^4.17.21",
+    "lodash-es": "^4.17.21",
+    "redis": "^4.7.0",
+    "winston": "^3.17.0"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.15",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^20",
+    "@typescript-eslint/eslint-plugin": "^8.23.0",
+    "@typescript-eslint/parser": "^8.23.0",
+    "azure-functions-core-tools": "^4.x",
+    "eslint": "^9",
+    "ngrok": "^5.0.0-beta.2",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.7.3"
+  }
+}

package/dist/ai-context/internal/examples/v1/me-and-u-connect/src/functions/healthCheck.ts

@@ -0,0 +1,14 @@
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+app.http('healthCheck', {
+    methods: ['GET', 'HEAD'],
+    authLevel: 'anonymous',
+    route: 'health',
+    handler: healthCheck
+});
+
+export async function healthCheck(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    return {
+        status: 200
+    }
+}

package/dist/ai-context/internal/examples/v1/me-and-u-connect/src/functions/meanduContactPolling.ts

@@ -0,0 +1,38 @@
+import { app, InvocationContext, Timer } from "@azure/functions";
+import { backgroundJobLogger } from '../lib/logging';
+
+import { startServices } from '../lib/services';
+import { jobNames, queueNames, triggerBackgroundJobWithQueue } from '../lib/jobs';
+import { listInstallations } from '../lib/state/seeka/installations';
+import { QueueClient } from "@azure/storage-queue";
+import winston from "winston";
+
+/// https://learn.microsoft.com/en-us/azure/azure-functions/functions-bindings-timer?tabs=python-v2%2Cisolated-process%2Cnodejs-v4&pivots=programming-language-typescript
+app.timer('meanduContactPolling', {
+    schedule: '0 45 * * * *', // every 45th minute of every hour - needs to consider the 3600 req/hour/account limit - https://apidocs.sproutsend.com/#rate-limiting
+    handler: meanduContactPolling
+});
+
+export async function meanduContactPolling(myTimer: Timer, context: InvocationContext): Promise<void> {
+    const logger = backgroundJobLogger(jobNames.scheduledPollMeAndUContactSyncJobName, undefined, context);
+
+    logger.profile(`job.${jobNames.scheduledPollMeAndUContactSyncJobName}`)
+    logger.info('Received request to trigger scheduled job');
+
+    await startServices(logger);
+
+    const allInstallations = await listInstallations(logger);
+    logger.verbose(`Triggering background job for ${allInstallations.length} installations`)
+
+    const queueClient = new QueueClient(process.env.AzureWebJobsStorage as string, queueNames.backgroundMeAndUContactSyncQueueName);
+    const promises = allInstallations.map(installation => triggerBackgroundJobWithQueue(queueClient, { ...installation, causationId: context.invocationId, correlationId: context.invocationId }, logger))
+
+    try {
+        await Promise.all(promises);
+    }
+    catch (err) {
+        logger.error('Error triggering background jobs', { err: err?.details, code: err?.code, ex: winston.exceptions.getAllInfo(err) })
+    }
+
+    logger.profile(`job.${jobNames.scheduledPollMeAndUContactSyncJobName}`)
+}

package/dist/ai-context/internal/examples/v1/me-and-u-connect/src/functions/meanduContactSync.ts

@@ -0,0 +1,69 @@
+import { app, InvocationContext } from "@azure/functions";
+import { SeekaActivityAcceptedWebhookContent } from "@seeka-labs/sdk-apps-server";
+import { groupBy } from "lodash";
+import winston from "winston";
+import {
+    BackgroundJobRequestContext, deserialiseQueuePayload, queueNames,
+    sendQueueMessageToPoisonQueue
+} from '../lib/jobs';
+import { backgroundJobLogger } from '../lib/logging';
+import { executeMeAndUContactSync } from '../lib/meandu/jobs/contact-sync';
+import { startServices } from "../lib/services";
+import { SeekaAppInstallState, tryGetInstallation } from "../lib/state/seeka/installations";
+
+app.storageQueue('meanduContactSync', {
+    queueName: queueNames.backgroundMeAndUContactSyncQueueName,
+    connection: 'AzureWebJobsStorage',
+    handler: meanduContactSync
+});
+
+export interface MeAndUMarketingOptInQueueItem extends BackgroundJobRequestContext {
+    items: SeekaActivityAcceptedWebhookContent[];
+}
+
+export async function meanduContactSync(queueItem: unknown, context: InvocationContext): Promise<void> {
+    const logger = backgroundJobLogger(queueNames.backgroundMeAndUContactSyncQueueName, undefined, context);
+    logger.profile(`queue.${queueNames.backgroundMeAndUContactSyncQueueName}`)
+
+    try {
+        // queueItem can either be a single item or an array of items
+        const payload = deserialiseQueuePayload<MeAndUMarketingOptInQueueItem>(queueItem, logger);
+
+        // Group by applicationInstallId
+        const grouped = groupBy(payload, e => e.applicationInstallId);
+
+        logger.verbose('Received queue batch to handle queue message', { batchSize: payload.length });
+
+        // Process each group
+        await startServices(logger);
+        for (const [applicationInstallId, items] of Object.entries(grouped)) {
+            if (items.length === 0) {
+                logger.warn('No items to process for applicationInstallId', { applicationInstallId });
+                continue;
+            }
+            const thisLogger = backgroundJobLogger(queueNames.backgroundMeAndUContactSyncQueueName, items[0], context);
+            try {
+                const installation = await tryGetInstallation(applicationInstallId, true, thisLogger) as SeekaAppInstallState;
+
+                // Execute sync
+                await executeMeAndUContactSync(installation, logger);
+            }
+            catch (err) {
+                thisLogger.error('Error handling queue item to handle queue message', { ex: winston.exceptions.getAllInfo(err) })
+                await sendQueueMessageToPoisonQueue(queueNames.backgroundMeAndUContactSyncQueueName, {
+                    ...items[0],
+                    causationId: items[0].causationId,
+                    correlationId: context.invocationId,
+                    rows: items.flatMap(e => e.items || []).filter(Boolean)
+                } as MeAndUMarketingOptInQueueItem, thisLogger);
+            }
+        }
+    }
+    catch (err) {
+        logger.error('Error handling queue item to handle queue message', { ex: winston.exceptions.getAllInfo(err) })
+        throw err; // Will retry based on host.json > extensions.queues.maxDequeueCount and then push to poison queue
+    }
+    finally {
+        logger.profile(`queue.${queueNames.backgroundMeAndUContactSyncQueueName}`)
+    }
+}

package/dist/ai-context/internal/examples/v1/me-and-u-connect/src/functions/seekaAppWebhook.ts

@@ -0,0 +1,162 @@
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";
+import type { Logger } from 'winston';
+
+import {
+    PersonIdentifiers, SeekaActivityAcceptedWebhookPayload, SeekaAppInstalledWebhookPayload,
+    SeekaAppInstallSettingsUpdatedWebhookPayload, SeekaAppUninstalledWebhookPayload,
+    SeekaIdentityChangedWebhookPayload, SeekaWebhookCallType, SeekaWebhookPayload,
+    throwOnInvalidWebhookSignature
+} from '@seeka-labs/sdk-apps-server';
+
+import { queueNames, triggerBackgroundJob } from '../lib/jobs';
+import { webhookLogger } from '../lib/logging';
+import { createOrUpdateContactFromSeekaPerson } from '../lib/meandu/contacts';
+import { createOrGetSeekaPersonIdCustomFieldExists } from '../lib/meandu/fields';
+import { createOrUpdateInstallation, deleteInstallation, SeekaAppInstallState, tryGetInstallation } from '../lib/state/seeka/installations';
+import { startServices } from '../lib/services';
+import winston from "winston";
+
+app.http('seekaAppWebhook', {
+    methods: ['POST'],
+    authLevel: 'anonymous',
+    route: 'webhook/seeka/app',
+    handler: seekaAppWebhook
+});
+
+export async function seekaAppWebhook(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    const bodyStr = (await req.text()) as string;
+    const body = JSON.parse(bodyStr) as SeekaWebhookPayload;
+
+    const logger = webhookLogger(body, context);
+    logger.profile('http.seeka.webhook.app')
+    logger.verbose('Received webhook from Seeka', { body });
+
+    // Handle probe
+    if (body.type === SeekaWebhookCallType.Probe) {
+        return {
+            status: 204
+        }
+    }
+
+    if (body.isTest) {
+        // This is a test webhook call
+    }
+
+    // Validate webhook
+    try {
+        throwOnInvalidWebhookSignature(process.env.SEEKA_APP_SECRET as string, req.headers, bodyStr);
+        logger.debug('Webhook signature validated', { body });
+    }
+    catch {
+        logger.warn('Webhook signature invalid', { body });
+        return {
+            status: 401,
+            jsonBody: { error: "Webhook call invalid" }
+        }
+    }
+    await startServices(logger);
+
+    // Check if the webhook is for an app we have installed
+    let installation: SeekaAppInstallState | null = null;
+    if (body.type != SeekaWebhookCallType.AppInstalled) {
+        installation = await tryGetInstallation((body as SeekaAppInstalledWebhookPayload).context?.applicationInstallId 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" }
+            }
+        }
+    }
+
+    // Do something
+    try {
+        switch (body.type) {
+            case SeekaWebhookCallType.AppInstalled:
+                {
+                    await onInstallation(body as SeekaAppInstalledWebhookPayload, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppInstallSettingsUpdated:
+                {
+                    await onInstallationSettingsUpdate(body as SeekaAppInstallSettingsUpdatedWebhookPayload, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppUninstalled:
+                {
+                    if (!body.isTest) {
+                        const payload = body as SeekaAppUninstalledWebhookPayload;
+                        await deleteInstallation(payload.context?.applicationInstallId as string, logger) // TODO: remove cast
+                    }
+                    break;
+                }
+            case SeekaWebhookCallType.IdentityChanged:
+                {
+                    const payload = body as SeekaIdentityChangedWebhookPayload;
+                    // TODO: remove casts
+                    await createOrUpdateContactFromSeekaPerson(installation, payload.content?.identifiers as PersonIdentifiers, logger);
+
+                    break;
+                }
+        }
+    }
+    catch (err) {
+        logger.error('Failed to handle webhook', { ex: winston.exceptions.getAllInfo(err) });
+        return {
+            status: 500,
+            jsonBody: { error: "Request failed" }
+        }
+    }
+    finally {
+        logger.profile('http.seeka.webhook.app')
+        logger.verbose('Seeka webhook handled');
+    }
+
+    return {
+        status: 204
+    }
+}
+
+const onInstallation = async (payload: SeekaAppInstalledWebhookPayload, logger: Logger) => {
+    if (payload.isTest) return;
+
+    const installation = await createOrUpdateInstallation({
+        ...payload.context,
+        applicationInstallId: payload.context?.applicationInstallId as string,
+        organisationBrandId: payload.context?.organisationBrandId as string,
+        organisationId: payload.context?.organisationId as string,
+        installationState: {
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        installedAt: new Date().toISOString(),
+        installationSettings: payload.content?.installationSettings || {}
+    }, logger)
+
+    // Ensure Seeka person ID field exists in MeAndU
+    await createOrGetSeekaPersonIdCustomFieldExists(installation, logger);
+
+    // Trigger a sync of all contacts in me&u - send to seeka to get a person ID and then update the contact in me&u with the person ID
+    await triggerBackgroundJob(queueNames.backgroundMeAndUContactSyncQueueName, {
+        ...payload.context,
+        causationId: payload.causationId,
+        correlationId: payload.requestId
+    }, logger)
+}
+
+const onInstallationSettingsUpdate = async (payload: SeekaAppInstallSettingsUpdatedWebhookPayload, logger: Logger) => {
+    if (payload.isTest) return;
+
+    const existingInstallation = await tryGetInstallation(payload.context?.applicationInstallId as string, true, logger) as SeekaAppInstallState;
+    const installation = await createOrUpdateInstallation({
+        ...existingInstallation,
+        installationState: {
+            ...existingInstallation.installationState,
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        installationSettings: payload.content?.installationSettings || {},
+    }, logger)
+
+    // Ensure Seeka person ID field exists in MeAndU
+    await createOrGetSeekaPersonIdCustomFieldExists(installation, logger);
+}