@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v1/tradable-bits/src/functions/seekaAppWebhook.ts

@@ -0,0 +1,157 @@
+import winston from 'winston';
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+import {
+    PersonIdentifiers, SeekaActivityAcceptedWebhookPayload, SeekaAppInstalledWebhookPayload,
+    SeekaAppInstallSettingsUpdatedWebhookPayload, SeekaAppUninstalledWebhookPayload,
+    SeekaIdentityChangedWebhookPayload, SeekaWebhookCallType, SeekaWebhookPayload,
+    throwOnInvalidWebhookSignature
+} from '@seeka-labs/sdk-apps-server';
+
+import { webhookLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import {
+    createOrUpdateInstallation, deleteInstallation, SeekaAppInstallState, tryGetInstallation
+} from '../lib/state/seeka/installations';
+
+import type { Logger } from 'winston';
+import { getSeekaBrowserPlugin } from '../lib/browser';
+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
+        }
+    }
+
+    // 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" }
+        }
+    }
+
+    if (body.isTest) {
+        // This is a test webhook call
+        return {
+            status: 204
+        }
+    }
+
+    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)
+                    }
+                    break;
+                }
+            case SeekaWebhookCallType.BrowserSdkPlugin: {
+                const plugin = await getSeekaBrowserPlugin(installation as SeekaAppInstallState, logger);
+
+                logger.profile('http.seeka.webhook.app')
+                return {
+                    status: 200,
+                    body: JSON.stringify(plugin),
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                }
+            }
+        }
+    }
+    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,
+        installationState: {
+            grantedPermissions: payload.content?.grantedPermissions || []
+        },
+        applicationInstallId: payload.context?.applicationInstallId as string,
+        organisationBrandId: payload.context?.organisationBrandId as string,
+        organisationId: payload.context?.organisationId as string,
+        installedAt: new Date().toISOString(),
+        installationSettings: payload.content?.installationSettings || {}
+    }, 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)
+}

package/dist/ai-context/internal/examples/v1/tradable-bits/src/lib/browser/index.ts

@@ -0,0 +1,54 @@
+import winston, { Logger } from 'winston';
+import fs from 'fs';
+import path from 'path';
+import util from 'util';
+import { SeekaBrowserSdkPluginWebhookResponse } from '@seeka-labs/sdk-apps-server'
+import {
+    SeekaAppInstallState
+} from '../state/seeka/installations';
+import type { ITradablebitsBrowserSdkPluginConfig } from '../models';
+
+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 = '../browser/seeka-app-tradablebits.min.js';
+        const browserPluginPath = path.resolve('./dist/src/browser/seeka-app-tradablebits.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 = {
+                fanSignUpEventName: installation.installationSettings.fanSignUpEventName,
+                appId: process.env.SEEKA_APP_ID,
+                appInstallId: installation.applicationInstallId,
+                appUrl: process.env.SELF_HOST_BASEURL
+            } as ITradablebitsBrowserSdkPluginConfig;
+            init = `TradablebitsConvergeSdkPlugin(${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/v1/tradable-bits/src/lib/logging/index.ts

@@ -0,0 +1,77 @@
+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';
+
+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,
+        })
+    )
+}
+
+export const logger = winston.createLogger({
+    level: process.env.LOGGING_LEVEL,
+    defaultMeta: {
+        seekaAppId: process.env.SEEKA_APP_ID,
+        Hosting_Provider: 'azure',
+        Release_Version: `v${packageJson.version}`,
+        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}`,
+    },
+    transports: loggerTransports,
+    exitOnError: false,
+});
+
+export const childLogger = (meta: object) => logger.child(meta);
+
+export const webhookLogger = (payload: SeekaWebhookPayload, functionContext: InvocationContext) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const meta: any = {
+        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/v1/tradable-bits/src/lib/models/index.ts

@@ -0,0 +1,6 @@
+export interface ITradablebitsBrowserSdkPluginConfig {
+    fanSignUpEventName: string
+    appId: string
+    appInstallId: string
+    appUrl: string
+}

package/dist/ai-context/internal/examples/v1/tradable-bits/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;
+    }
+}

package/dist/ai-context/internal/examples/v1/tradable-bits/src/lib/state/redis/index.ts

@@ -0,0 +1,64 @@
+import { createClient } from 'redis';
+
+import { logger } from '../../logging';
+
+const redisProtocol = process.env.REDIS_CONNECTION_TLS === 'true' ? 'rediss://' : 'redis://';
+const redisConn = `${redisProtocol}${process.env.REDIS_CONNECTION_USER}:${process.env.REDIS_CONNECTION_PASSWORD}@${process.env.REDIS_CONNECTION_HOST}:${process.env.REDIS_CONNECTION_PORT}`;
+
+const redisClient = createClient({
+    url: redisConn
+})
+    .on('error', err => logger.error('Redis Client ', { error: err }));
+
+export const connect = async () => {
+    await redisClient.connect();
+}
+
+export const isConnected = () => {
+    return redisClient.isOpen;
+}
+
+export const disconnect = async () => {
+    await redisClient.disconnect();
+}
+
+const getKeyPrefix = (stateType: string) => `seeka:app:${process.env.SEEKA_APP_ID}:${stateType}`
+const getKey = (stateType: string, key: string) => `${getKeyPrefix(stateType)}:${key}`
+
+export async function getOrCreate<TState>(stateType: string, key: string, toCreate: TState): Promise<TState> {
+    const fullKey = getKey(stateType, key);
+    const existingStr = await redisClient.get(fullKey);
+    if (existingStr) return JSON.parse(existingStr);
+
+    await redisClient.set(fullKey, JSON.stringify(toCreate));
+
+    return toCreate;
+}
+
+export async function tryGet<TState>(stateType: string, key: string): Promise<TState | null> {
+    const fullKey = getKey(stateType, key);
+    const existingStr = await redisClient.get(fullKey);
+    if (existingStr) return JSON.parse(existingStr);
+
+    return null;
+}
+
+export async function getList<TState>(stateType: string): Promise<TState[]> {
+    const prefix = getKeyPrefix(stateType);
+    const allKeys = await redisClient.keys(`${prefix}:*`);
+    const listStr = await redisClient.mGet(allKeys);
+
+    if (listStr) return listStr.filter(e => Boolean(e)).map(e => JSON.parse(e as string));
+
+    return [];
+}
+
+export async function set<TState>(stateType: string, key: string, toCreate: TState): Promise<void> {
+    const fullKey = getKey(stateType, key);
+    await redisClient.set(fullKey, JSON.stringify(toCreate));
+}
+
+export async function remove(stateType: string, key: string): Promise<void> {
+    const fullKey = getKey(stateType, key);
+    await redisClient.del(fullKey);
+}

package/dist/ai-context/internal/examples/v1/tradable-bits/src/lib/state/seeka/installations.ts

@@ -0,0 +1,64 @@
+import type { Logger } from 'winston';
+
+import { getList, remove, set, tryGet } from '../redis';
+
+export interface SeekaAppInstallState {
+    /** ID of the organisation that installed the app */
+    organisationId: string;
+    /** ID of the brand that installed the app */
+    organisationBrandId: string;
+    /** ID of the installation of the app */
+    applicationInstallId: string;
+    // Installation settings provided by the user installing the app
+    installationSettings: TradableBitsAppInstallSettings
+    // State relating to the app and installation of the app
+    installationState: TradableBitsAppInstallState;
+
+    // When the app was installed
+    installedAt: string; // new Date().toISOString()
+}
+
+export interface TradableBitsAppInstallState {
+    grantedPermissions?: string[]
+}
+
+export type TradableBitsAppInstallSettings = { [key: string]: any; } | {
+    fanSignUpEventName: string | undefined;
+}
+
+const stateType = 'install'
+
+export const tryGetInstallation = async (applicationInstallId: string, throwWhenNotFound: boolean, logger: Logger): Promise<SeekaAppInstallState | null> => {
+    const installation = await tryGet<SeekaAppInstallState>(stateType, applicationInstallId);
+    if (installation == null && throwWhenNotFound) {
+        throw new Error(`Seeka installation ${applicationInstallId} not found`);
+    }
+
+    return installation;
+}
+
+export const listInstallations = async (logger: Logger): Promise<SeekaAppInstallState[]> => {
+    const installations = await getList<SeekaAppInstallState>(stateType);
+
+    return installations;
+}
+
+
+export const createOrUpdateInstallation = async (state: SeekaAppInstallState, logger: Logger): Promise<SeekaAppInstallState> => {
+    if (!state.installationState) state.installationState = {};
+    if (!state.installedAt) state.installedAt = new Date().toISOString();
+
+    const creating = (await tryGetInstallation(state.applicationInstallId, false, logger)) === null;
+
+    await set(stateType, state.applicationInstallId, state);
+
+    logger.info(creating ? 'Created installation state' : 'Updated installation state', { applicationInstallId: state.applicationInstallId, organisationId: state.organisationId, organisationBrandId: state.organisationBrandId });
+
+    return state;
+}
+
+export const deleteInstallation = async (applicationInstallId: string, logger: Logger): Promise<void> => {
+    await remove(stateType, applicationInstallId);
+
+    logger.info('Deleted installation state', { applicationInstallId });
+}

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

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "esModuleInterop": true,
+    "outDir": "dist",
+    "rootDir": ".",
+    "sourceMap": true,
+    "module": "CommonJS",
+    "target": "ES6",
+    "resolveJsonModule": true,
+    "isolatedModules": false,
+  },
+  "include": [
+    "src/functions/*.ts"
+  ]
+}

package/dist/ai-context/internal/examples/v1/transcend/.eslintrc.cjs

@@ -0,0 +1,19 @@
+/* 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": "off"
+    },
+    overrides: [
+        {
+            files: ["**/*/*.test.ts"],
+            env: {
+                jest: true
+            }
+        }
+    ]
+};

package/dist/ai-context/internal/examples/v1/transcend/README.md

@@ -0,0 +1,112 @@
+# Seeka app - Azure functions
+
+## Transcend docs
+https://docs.transcend.io/docs/articles/consent-management/configuration/tracking-purposes
+IAB CMP ID for Transcend: 399
+
+## 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, the following may be required to allow your app to reach Azure storage emulator: 
+
+        Replace `MY-MACHINE-NAME` 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://MY-MACHINE-NAME.local:10000/devstoreaccount1;QueueEndpoint=http://MY-MACHINE-NAME.local:10001/devstoreaccount1;TableEndpoint=http://MY-MACHINE-NAME.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 dev`
+
+### 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`.
+3. Input the URL into your Seeka app configuration as the "Webook URL" via the Seeka UI.
+
+## Included sample functions
+### Seeka app webhook 
+`src/functions/seekaAppWebhook.ts`
+
+Handles inbound webhooks sent from Seeka to your app.
+
+### Queue example 
+`src/functions/queueExample.ts`
+
+Handles taking a message and placing it on an Azure storage queue for later processing. This concept can be used to offload long running operations based on data sent to your app from Seeka and can help to ensure Azure Function time execution limits are respected.
+
+### Polling example 
+`src/functions/pollingExample.ts`
+
+Handles scheduled invoking of a function. This concept can be used to "fan out" long running operations based on data sent to your app from Seeka and can help to ensure Azure Function time execution limits are respected by splitting long running operations into smaller, less time consuming parts.
+
+## Invoking functions
+### Development environment
+Scheduled / timer function: `curl -i -d '{"input": null}' -H "Content-Type: application/json" -X POST http://localhost:7072/admin/functions/pollingExample`
+
+### 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-transcend.azurewebsites.net/admin/functions/pollingExample`
+
+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
+Centralised logging handled by [Winston](https://www.npmjs.com/package/winston). Winston is installed in this template and is also used in the Seeka SDK NPM packages.
+
+[Seq](https://datalust.co/seq) Winston transport is installed in this template (optional).
+
+To configure Seq options, see `_SEQ_` environment variables.
+
+To install Seq on your development machine
+1. Run `docker run --name seq -d --restart=always -e ACCEPT_EULA=Y -p 5341:80 datalust/seq:2024.2`
+2. Update your `LOGGING_SEQ_SERVERURL` environment variable to `http://localhost:5341` or `http://[YOUR MACHINE NAME].local:5341` if using WSL.
+
+If creating an API key for Seq, only permission that is required is `Ingest`.
+
+## State management
+Installations of your app and other state required for your app to function is stored in Redis. Another state provider can be swapped out for Redis, 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 the connection strings in `.env` can be swapped with your Redis instance. 
+
+> If using Upstash then create a database before following the below guide to deploying your AWS lambda function.
+
+> When choosing region - use a region that is closest to the Azure region that your function app is hosted in to reduce latency between the function and the Redis database. 
+
+## 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.
+
+1. Create Azure function app via the portal with below settings
+    - Function app name: seeka-app-transcend
+    - Code or container image: Code
+    - Runtime stack: Node.js
+    - Version: 20
+    - Region: Closest region to where your upstash "master / write" database is located
+    - Operating system: linux
+    - Hosting: Consumption
+    - Enable public access: On
+2. Set environment variables of the Azure web app - reference local.settings.json "Values" 
+3. If your app receives calls directly from the browser (eg. your browser app plugin) then CORS needs to be enabled for all origins from within the settings of the Function app in Azure portal.
+3. `yarn deploy`
+
+### Continuous delivery
+This template includes a GitLab CD pipeline that can be used to trigger deployments of your app when changes are pushed to your Git repository.
+
+### Configuring queues
+See [this article](https://learn.microsoft.com/en-us/azure/azure-functions/functions-bindings-storage-queue?tabs=isolated-process%2Cextensionv5%2Cextensionv3&pivots=programming-language-typescript#host-json) on settings that are settable in the `host.json` file.
+
+## 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/transcend/_ai-summary.md

@@ -0,0 +1,36 @@
+# AI Summary for Seeka App: Transcend
+
+## Purpose and Functionality
+The Transcend app integrates with the Transcend data privacy platform to manage consent and data rights, ensuring compliance with privacy regulations. It facilitates the handling of webhooks from Seeka, processes data rights requests, and manages installations and settings updates.
+
+## Key Implementation Patterns
+- **Azure Functions**: The app is built using Azure Functions, allowing it to handle HTTP requests, manage queues, and perform scheduled tasks.
+- **Webhook Handling**: The app processes various webhook events from Seeka, such as app installations, settings updates, and activity acceptance.
+- **State Management**: Redis is used for storing app installation states, with the option to swap for another state provider.
+- **Centralized Logging**: Utilizes Winston for logging, with optional integration with Seq for structured log management.
+
+## External APIs/Services Integrated
+- **Transcend**: Integrates with Transcend for consent and data rights management.
+- **Azure Storage**: Uses Azure Storage Queues for managing asynchronous operations.
+- **Redis**: Employed for state management, with optional integration with Upstash.
+- **Ngrok**: Used for exposing local development environments to the internet for testing.
+
+## Important Data Transformations
+- **Webhook Payload Processing**: Parses and validates webhook payloads, ensuring the integrity and authenticity of incoming data.
+- **Installation State Management**: Handles the creation, update, and deletion of app installation states based on webhook events.
+
+## Notable Code Patterns
+- **Webhook Signature Validation**: Ensures security by validating webhook signatures before processing.
+- **Queue Management**: Demonstrates how to offload long-running operations to Azure Storage Queues to respect Azure Function execution limits.
+- **Modular Service Initialization**: Uses a `startServices` function to initialize necessary services, promoting modularity and separation of concerns.
+- **Browser SDK Plugin Handling**: Integrates browser-specific plugins conditionally, showcasing a pattern for component-based architecture.
+
+## Development and Deployment
+- **Local Development**: Supports local development with Docker for Azure Storage emulation and Ngrok for exposing local servers.
+- **Deployment**: Provides scripts for deploying the app to Azure, ensuring a streamlined deployment process.
+
+## Debugging and Testing
+- **VSCode Debugging**: Configured for debugging with VSCode, supporting breakpoints and step-through debugging.
+- **Testing**: Uses Jest for testing, ensuring code reliability and robustness.
+
+This summary provides an overview of the Transcend app's architecture, integration points, and implementation patterns, offering a comprehensive understanding for AI assistants and developers.