@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v1/complianz/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/complianz/jest.config.js

@@ -0,0 +1,5 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+    preset: 'ts-jest',
+    testEnvironment: 'node',
+};

package/dist/ai-context/internal/examples/v1/complianz/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "seeka-app-complianz",
+  "version": "1.1.13",
+  "description": "Seeka app seeka-app-complianz",
+  "author": "Seeka company <support@seeka.co>",
+  "license": "MIT",
+  "main": "dist/src/functions/*.js",
+  "private": true,
+  "engines": {
+    "node": ">=18.14.0"
+  },
+  "scripts": {
+    "lint": "eslint",
+    "build": "yarn clean && tsc && cd src/browser && yarn && yarn build && cd ../",
+    "watch": "cd src/browser && yarn && yarn build && cd ../ && tsc -w",
+    "test": "yarn jest",
+    "clean": "yarn rimraf dist",
+    "prestart": "yarn clean && yarn build",
+    "dev": "yarn build && func start --port 7072",
+    "tunnel": "node scripts/ngrok.js seeka-app-complianz-localdev",
+    "deploy": "yarn clean && yarn build && func azure functionapp publish seeka-app-complianz --no-build --javascript",
+    "dev:queue:create": "node scripts/dev-queue-setup.js sample-queue-name"
+  },
+  "dependencies": {
+    "@azure/functions": "^4.6.0",
+    "@datalust/winston-seq": "^2.0.0",
+    "@seeka-labs/sdk-apps-server": "^1.1.18",
+    "axios": "^1.7.8",
+    "lodash-es": "^4.17.21",
+    "openid-client": "^5.7.1",
+    "redis": "^4.7.0",
+    "winston": "^3.17.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "^29.7.0",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^20",
+    "@typescript-eslint/eslint-plugin": "^8.16.0",
+    "@typescript-eslint/parser": "^8.16.0",
+    "azure-functions-core-tools": "^4.x",
+    "eslint": "^8",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.5",
+    "ngrok": "^5.0.0-beta.2",
+    "rimraf": "^5.0.0",
+    "typescript": "^5.7.2"
+  }
+}

package/dist/ai-context/internal/examples/v1/complianz/src/browser/.eslintrc.cjs

@@ -0,0 +1 @@
+module.exports = require('../../scripts/eslint/shared.eslint.cjs');

package/dist/ai-context/internal/examples/v1/complianz/src/browser/.yarnrc

@@ -0,0 +1 @@
+"@seeka-labs:registry" "https://npm.packages.seeka.services/"

package/dist/ai-context/internal/examples/v1/complianz/src/browser/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "seeka-app-complianz-browser",
+  "version": "1.0.3",
+  "description": "Seeka browser app seeka-app-complianz-browser",
+  "author": "Seeka company <support@seeka.co>",
+  "license": "MIT",
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "lint": "eslint --fix src/ --ext .ts",
+    "test:ci": "jest --collectCoverage --coverageDirectory=\"./coverage\" --ci --reporters=default --reporters=jest-junit --watchAll=false",
+    "test": "jest --watch",
+    "clean": "rimraf dist build package",
+    "build": "yarn clean && node ./scripts/esbuild/build-browser-plugin.mjs seeka-app-complianz ComplianzAppConvergeSdkPlugin",
+    "build:dev": "yarn clean && node ./scripts/esbuild/build-browser-plugin.mjs seeka-app-complianz ComplianzAppConvergeSdkPlugin dev",
+    "watch": "yarn clean && node ./scripts/esbuild/build-browser-plugin.mjs seeka-app-complianz ComplianzAppConvergeSdkPlugin dev watch"
+  },
+  "dependencies": {
+    "@seeka-labs/converge": "^1.8.45"
+  },
+  "devDependencies": {
+    "@jgoz/esbuild-plugin-typecheck": "^4.0.2",
+    "@types/jest": "^29.5.14",
+    "@types/jquery": "^3.5.32",
+    "@typescript-eslint/eslint-plugin": "^8.16.0",
+    "@typescript-eslint/parser": "^8.16.0",
+    "esbuild": "^0.24.0",
+    "eslint": "^9.15.0",
+    "eslint-plugin-unused-imports": "^4.1.4",
+    "jest": "^29.7.0",
+    "jest-junit": "^16.0.0",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.7.2",
+    "watch": "^1.0.2"
+  }
+}

package/dist/ai-context/internal/examples/v1/complianz/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/complianz/src/functions/seekaAppWebhook.ts

@@ -0,0 +1,190 @@
+import winston from 'winston';
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+import {
+    SeekaAppInstalledWebhookPayload,
+    SeekaAppInstallSettingsUpdatedWebhookPayload, SeekaAppUninstalledWebhookPayload,
+    SeekaWebhookCallType, SeekaWebhookPayload,
+    throwOnInvalidWebhookSignature
+} from '@seeka-labs/sdk-apps-server';
+
+import { getSeekaBrowserPlugin } from '../lib/browser'
+
+import { webhookLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import {
+    createOrUpdateInstallation, deleteInstallation, ComplianzAppInstallSettings, SeekaAppInstallState, tryGetInstallation
+} from '../lib/state/seeka/installations';
+
+import type { Logger } 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;
+    if (!bodyStr) {
+        return {
+            status: 400,
+            jsonBody: { error: "Body missing. Ensure body is present and either specify the Content-Length request header OR set Transfer-Encoding request header to 'chunked'" }
+        }
+    }
+    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
+    let errorMessage: string | null = null;
+    try {
+        switch (body.type) {
+            case SeekaWebhookCallType.AppInstalled:
+                {
+                    errorMessage = await onInstallation(body as SeekaAppInstalledWebhookPayload, logger);
+                    break;
+                }
+            case SeekaWebhookCallType.AppInstallSettingsUpdated:
+                {
+                    errorMessage = 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');
+    }
+
+    if (errorMessage) {
+        logger.warn('Webhook call failed', { errorMessage });
+        return {
+            status: 400,
+            jsonBody: { error: { message: errorMessage } }
+        }
+    }
+
+    return {
+        status: 204
+    }
+}
+
+const validateInstallationSettings = async (installSettings: ComplianzAppInstallSettings, logger: Logger): Promise<string | null> => {
+    // Returning an error message string here will block the installation request or settings update request by the user installing the app
+
+
+    return null;
+}
+
+const onInstallation = async (payload: SeekaAppInstalledWebhookPayload, logger: Logger): Promise<string | null> => {
+    if (payload.isTest) return null;
+
+    const errorMessage = await validateInstallationSettings(payload.content?.installationSettings || {}, logger);
+    if (errorMessage) return errorMessage;
+
+    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)
+
+    return null;
+}
+
+const onInstallationSettingsUpdate = async (payload: SeekaAppInstallSettingsUpdatedWebhookPayload, logger: Logger): Promise<string | null> => {
+    if (payload.isTest) return null;
+
+    const errorMessage = await validateInstallationSettings(payload.content?.installationSettings || {}, logger);
+    if (errorMessage) return errorMessage;
+
+    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)
+
+    return null;
+}

package/dist/ai-context/internal/examples/v1/complianz/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/v1/complianz/src/lib/browser/index.ts

@@ -0,0 +1,53 @@
+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 { IComplianzAppBrowserSdkPluginConfig } 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 = path.resolve('./dist/src/browser/seeka-app-complianz.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.
+            // Configuration is sent to the browser so NO SENSITIVE CONFIG / SERVER SECRETS SHOULD BE SPECIFIED HERE.
+            const pluginConfig = {
+                appId: process.env.SEEKA_APP_ID,
+                appInstallId: installation.applicationInstallId,
+                appUrl: process.env.SELF_HOST_BASEURL
+            } as IComplianzAppBrowserSdkPluginConfig;
+            init = `ComplianzAppConvergeSdkPlugin(${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/complianz/src/lib/browser/models/index.ts

@@ -0,0 +1,5 @@
+export interface IComplianzAppBrowserSdkPluginConfig {
+    appId: string
+    appInstallId: string
+    appUrl: string
+}

package/dist/ai-context/internal/examples/v1/complianz/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/complianz/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/complianz/src/lib/state/redis/index.ts

@@ -0,0 +1,65 @@
+import { createClient } from 'redis';
+
+import { logger } from '../../logging';
+import winston from 'winston';
+
+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: any) => logger.error('Redis Client ', { ex: winston.exceptions.getAllInfo(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/complianz/src/lib/state/seeka/installations.ts

@@ -0,0 +1,62 @@
+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: ComplianzAppInstallSettings
+    // State relating to the app and installation of the app
+    installationState: ComplianzAppInstallState;
+
+    // When the app was installed
+    installedAt: string; // new Date().toISOString()
+}
+
+export interface ComplianzAppInstallState {
+    grantedPermissions?: string[]
+}
+
+export type ComplianzAppInstallSettings = { [key: string]: any; }
+
+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/complianz/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/ivvy/.eslintrc.cjs

@@ -0,0 +1,10 @@
+/* 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"
+    }
+};