@seeka-labs/cli-apps 3.8.8 → 3.8.10

package/dist/ai-context/internal/examples/v1/activecampaign/src/lib/active-campaign/pipelines/index.ts

@@ -1,206 +0,0 @@
-import { ActivityPayloadBase, TrackingActivityNames } from "@seeka-labs/sdk-apps-server";
-import { ActiveCampaignPipelineLookupInfo, DealMappingDefinitionStage, SeekaAppInstallState, createOrUpdateInstallation } from "../../state/seeka/installations";
-import { DealMappingDefinition } from "../..//state/seeka/installations";
-import { Logger } from "winston";
-import { get } from "lodash";
-import { makeActiveCampaignApiRequest } from "../api";
-
-export const getMatchingPipelineMapper = (installation: SeekaAppInstallState, activity: ActivityPayloadBase, logger: Logger): { mapper: DealMappingDefinition, activeCampaignPipeline: ActiveCampaignPipelineLookupInfo, stage: DealMappingDefinitionStage } | null => {
-    if (!installation.installationSettings.enableDealPipelines) return null;
-
-    const mappers = installation.installationSettings.dealMappers || [];
-    if (!mappers) return null;
-
-    const eventName = activity.activityName === TrackingActivityNames.Custom ? activity.activityNameCustom : activity.activityName.toString();
-    const eventNameUpper = eventName.toUpperCase();
-    for (const mapper of mappers) {
-        if (mapper.dealTriggerEventName && mapper.dealTriggerEventName.toUpperCase() === eventNameUpper) {
-            logger.verbose('Found matching pipeline mapper', { mapper, activityName: eventName });
-
-            const stageNameLookupPropValue = getPropFromActivity(activity, mapper.dealStageNameParam);
-            if (!stageNameLookupPropValue) {
-                logger.verbose('No stage name could be located from activity', { activity, mapper, dealStageNameParam: mapper.dealStageNameParam });
-                return null;
-            }
-            else {
-                logger.verbose('Found stage name lookup prop value', { stageNameLookupPropValue });
-            }
-
-            // Match to stage
-            const pipelineInfo = installation.installationState.dealMapperNamesToActiveCampaignPipelineInfo[mapper.pipelineName];
-            if (pipelineInfo) {
-                logger.debug('Found pipeline info for mapper', { mapper, pipelineInfo });
-                return {
-                    mapper: mapper,
-                    activeCampaignPipeline: pipelineInfo,
-                    stage: mapper.dealStages.find(s => s.name === stageNameLookupPropValue)
-                }
-            }
-        }
-    }
-
-    return null;
-}
-
-const getPropFromActivity = (activity: ActivityPayloadBase, propName: string): string | undefined => {
-    if (propName.startsWith('custom')) {
-        return activity.properties[propName.replace('custom.', '')] || undefined;
-    }
-
-    return get(activity, propName) || undefined;
-}
-
-const createPipelineInActiveCampaign = async (installation: SeekaAppInstallState, pipeline: ActiveCampaignPipeline, logger: Logger): Promise<ActiveCampaignPipelineWithId> => {
-    // https://developers.activecampaign.com/reference/create-a-pipeline
-    const response = await makeActiveCampaignApiRequest<ActiveCampaignCreatePipelineResponse>(`/api/3/dealGroups`, 'POST', {
-        dealGroup: pipeline
-    }, installation, logger);
-
-    return response.dealGroup;
-}
-
-const listPipelinesInActiveCampaign = async (installation: SeekaAppInstallState, logger: Logger): Promise<ActiveCampaignListPipelinesResponse> => {
-    // https://developers.activecampaign.com/reference/list-all-pipelines
-    // TODO: Support retrieving more than 100 pipelines
-    const response = await makeActiveCampaignApiRequest<ActiveCampaignListPipelinesResponse>(`/api/3/dealGroups?limit=100`, 'GET', undefined, installation, logger);
-
-    return response;
-}
-
-const updatePipelineStageInActiveCampaign = async (installation: SeekaAppInstallState, pipelineId: string, stageId: string, order: number, logger: Logger): Promise<void> => {
-    await makeActiveCampaignApiRequest<unknown>(`/api/3/dealStages/${stageId}`, 'PUT', {
-        dealStage: {
-            // "cardRegion1": "title",
-            // "cardRegion2": "next-action",
-            // "cardRegion3": "show-avatar",
-            // "cardRegion4": "contact-fullname-orgname",
-            // "cardRegion5": "value",
-            // "color": "32B0FC",
-            // "dealOrder": "next-action DESC",
-            "group": pipelineId,
-            "order": order,
-            // "width": 360
-        }
-    }, installation, logger);
-}
-
-const createPipelineStageInActiveCampaign = async (installation: SeekaAppInstallState, pipelineId: string, stageName: string, order: number, logger: Logger): Promise<ActiveCampaignPipelineStage> => {
-    const response = await makeActiveCampaignApiRequest<{ dealStage: ActiveCampaignPipelineStage }>(`/api/3/dealStages`, 'POST', {
-        dealStage: {
-            // "cardRegion1": "title",
-            // "cardRegion2": "next-action",
-            // "cardRegion3": "show-avatar",
-            // "cardRegion4": "contact-fullname-orgname",
-            // "cardRegion5": "value",
-            // "color": "32B0FC",
-            // "dealOrder": "next-action DESC",
-            "group": pipelineId,
-            "order": order,
-            "title": stageName,
-            // "width": 360
-        }
-    }, installation, logger);
-
-    return { ...response.dealStage };
-}
-
-// const tryGetPipelineFromActiveCampaign = async (installation: SeekaAppInstallState, pipelineName: string, logger: Logger) => {
-
-// }
-
-export const maintainPipelinesForInstallation = async (installation: SeekaAppInstallState, logger: Logger) => {
-    if (!installation.installationSettings.enableDealPipelines || !installation.installationSettings.dealMappers || installation.installationSettings.dealMappers.length === 0) return;
-
-    const pipelineMappings = installation.installationState.dealMapperNamesToActiveCampaignPipelineInfo;
-
-    const existingPipelines = await listPipelinesInActiveCampaign(installation, logger);
-
-    for (const mapper of installation.installationSettings.dealMappers) {
-        // Try find pipeline in ActiveCampaign
-        let activeCampaignPipeline: ActiveCampaignPipelineWithId | undefined = existingPipelines.dealGroups.find(p => p.title === mapper.pipelineName);
-
-        if (!activeCampaignPipeline) {
-            // Create pipeline in ActiveCampaign
-            activeCampaignPipeline = await createPipelineInActiveCampaign(installation, {
-                title: mapper.pipelineName,
-                autoassign: ActiveCampaignPipelineAutoassignType.RoundRobin,
-                currency: mapper.dealCurrencyCode?.toLowerCase()
-            }, logger);
-        }
-
-        pipelineMappings[mapper.pipelineName] = {
-            pipelineId: activeCampaignPipeline.id,
-            stageNamesToStageIds: {}
-        };
-
-        // Maintain stages
-        const pipelineInfo = pipelineMappings[mapper.pipelineName];
-        if (!pipelineInfo) {
-            logger.error('Pipeline info not found for mapper', { mapper });
-            continue;
-        }
-        if (!mapper.dealStages || mapper.dealStages.length === 0) {
-            logger.error('No deal stages found on mapper', { mapper });
-            continue;
-        }
-
-        mapper.dealStages.forEach(async (stage, index) => {
-            const stageName = stage.name;
-            const activeCampaignIndex = index + 1;
-            // Try find stage in ActiveCampaign
-            let pipelineStage: ActiveCampaignPipelineStage | undefined = existingPipelines.dealStages.find(s => s.title === stageName && s.group === pipelineInfo.pipelineId);
-
-            if (!pipelineStage) {
-                // Create stage in ActiveCampaign
-                logger.verbose('Stage doesnt exist in mapping, creating in ActiveCampaign', { stageName, pipelineName: mapper.pipelineName });
-                pipelineStage = await createPipelineStageInActiveCampaign(installation, pipelineInfo.pipelineId, stageName, activeCampaignIndex, logger);
-            }
-            else if (pipelineStage.order !== activeCampaignIndex.toString()) {
-                // Update state order
-                logger.verbose('Stage already exists in mapping and order is different, updating it in ActiveCampaign', { stageName, pipelineName: mapper.pipelineName });
-                await updatePipelineStageInActiveCampaign(installation, pipelineInfo.pipelineId, pipelineInfo.stageNamesToStageIds[stageName], activeCampaignIndex, logger)
-            }
-
-            pipelineInfo.stageNamesToStageIds[stageName] = pipelineStage.id;
-        });
-    }
-
-    installation.installationState.dealMapperNamesToActiveCampaignPipelineInfo = pipelineMappings;
-
-    await createOrUpdateInstallation(installation, logger);
-}
-
-export interface ActiveCampaignPipeline {
-    allgroups?: number;
-    allusers?: number;
-    autoassign?: ActiveCampaignPipelineAutoassignType;
-    currency?: string;
-    title: string
-}
-
-export enum ActiveCampaignPipelineAutoassignType {
-    Disabled = 0,
-    RoundRobin = 1,
-    DealValue = 2,
-}
-
-export interface ActiveCampaignCreatePipelineResponse {
-    dealGroup: ActiveCampaignPipelineWithId
-}
-
-export interface ActiveCampaignListPipelinesResponse {
-    dealGroups: ActiveCampaignPipelineWithId[]
-    dealStages: ActiveCampaignPipelineStage[]
-}
-
-export interface ActiveCampaignPipelineWithId extends ActiveCampaignPipeline {
-    id: string
-    stages: string[]
-}
-
-export interface ActiveCampaignPipelineStage {
-    id: string
-    title: string
-    group: string
-    order: string
-}

package/dist/ai-context/internal/examples/v1/activecampaign/src/lib/logging/index.ts

@@ -1,77 +0,0 @@
-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,
-        }) as never
-    )
-}
-
-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/activecampaign/src/lib/services/index.ts

@@ -1,41 +0,0 @@
-import { connect, disconnect, isConnected } from "../state/redis";
-import { Logger } from "winston";
-import * as winston from "winston";
-
-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.info(`Redis connected - ${process.env.REDIS_CONNECTION_HOST}`)
-        }
-    }
-    catch (err) {
-        logger.error(`Failed to connect to Redis - ${process.env.REDIS_CONNECTION_HOST}`, { exception: 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.info(`Redis disconnected - ${process.env.REDIS_CONNECTION_HOST}`)
-        }
-    }
-    catch (err) {
-        logger.error(`Failed to disconnect from Redis - ${process.env.REDIS_CONNECTION_HOST}`, { exception: winston.exceptions.getAllInfo(err) })
-        throw err;
-    }
-}

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

@@ -1,64 +0,0 @@
-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/activecampaign/src/lib/state/seeka/installations.ts

@@ -1,96 +0,0 @@
-import type { Logger } from 'winston';
-
-import { getList, remove, set, tryGet } from '../redis';
-import { ActiveCampaignPipelineDealStatus } from '../../active-campaign/pipelines/deals';
-
-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: ActiveCampaignInstallSettings;
-    // State relating to the app and installation of the app
-    installationState: ActiveCampaignInstallState;
-
-    // When the app was installed
-    installedAt: string; // new Date().toISOString()
-}
-
-export interface ActiveCampaignInstallState {
-    dealMapperNamesToActiveCampaignPipelineInfo?: { [key: string]: ActiveCampaignPipelineLookupInfo }
-    grantedPermissions?: string[]
-}
-
-export interface ActiveCampaignPipelineLookupInfo {
-    pipelineId: string
-    stageNamesToStageIds: { [key: string]: string }
-}
-
-export interface DealMappingDefinition {
-    pipelineName?: string
-    dealTriggerEventName?: string
-    dealCurrencyCode?: string
-    dealIdParam?: string
-    dealStageNameParam?: string
-    dealStages?: DealMappingDefinitionStage[]
-}
-
-export interface DealMappingDefinitionStage {
-    name: string
-    status: DealMappingDefinitionStageStatus
-}
-
-export type DealMappingDefinitionStageStatus = 'open' | 'won' | 'lost'
-
-export interface ActiveCampaignInstallSettings {
-    activeCampaignApiUrl?: string
-    activeCampaignApiKey?: string
-    enableDealPipelines?: boolean
-    dealMappers?: DealMappingDefinition[]
-}
-
-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`);
-    }
-
-    // TODO: Decrypt the ActiveCampaign API key at rest
-
-    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();
-    if (!state.installationSettings) state.installationSettings = {};
-    if (!state.installationState.dealMapperNamesToActiveCampaignPipelineInfo) state.installationState.dealMapperNamesToActiveCampaignPipelineInfo = {};
-
-    // TODO: Encrypt the ActiveCampaign API key at rest
-
-    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/activecampaign/tsconfig.json

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

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

@@ -1,19 +0,0 @@
-/* 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/complianz/README.md

@@ -1,105 +0,0 @@
-# Seeka app - Azure functions
-
-## 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-complianz.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-complianz
-    - Code or container image: Code
-    - Runtime stack: Node.js
-    - Version: 18 LTS
-    - 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.
-
-## 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/complianz/_ai-summary.md

@@ -1,36 +0,0 @@
-# AI Summary for Seeka App: Complianz
-
-## Overview
-The Complianz app is designed for consent management integration, ensuring compliance with GDPR and privacy regulations. It leverages Azure Functions to handle various consent-related operations and integrates with Seeka's ecosystem to manage app installations and webhooks.
-
-## Purpose and Functionality
-- **Consent Management**: The app facilitates GDPR compliance by managing user consents.
-- **Webhook Handling**: Processes inbound webhooks from Seeka to manage app installation states.
-- **Queue and Polling**: Utilizes Azure storage queues for offloading long-running operations and scheduled polling for task distribution.
-
-## Key Implementation Patterns
-- **Azure Functions**: The app is structured around Azure Functions, providing a serverless architecture for handling HTTP requests and background tasks.
-- **Webhook Processing**: Implements a robust webhook handling mechanism with signature validation and state management.
-- **State Management**: Uses Redis for storing installation states, which can be swapped with other state providers if needed.
-
-## External APIs/Services Integrated
-- **Azure Functions**: Core service for running serverless functions.
-- **Redis**: Used for managing state related to app installations.
-- **Ngrok**: Facilitates local development by exposing the app to the internet for testing.
-- **Seq and Winston**: Used for centralized logging and monitoring.
-
-## Important Data Transformations
-- **Webhook Payload Processing**: Transforms incoming webhook payloads to manage app states and settings.
-- **Queue Message Handling**: Processes messages placed in Azure storage queues for deferred execution of tasks.
-
-## Notable Code Patterns
-- **Centralized Logging**: Utilizes Winston for logging, with optional Seq integration for enhanced log management.
-- **Environment Configuration**: Supports local and cloud environments with detailed setup instructions for development and deployment.
-- **Error Handling**: Implements comprehensive error handling and logging for webhook processing to ensure reliability and traceability.
-
-## Reusable Code Patterns
-- **Webhook Signature Validation**: The pattern for validating webhook signatures can be reused in other applications requiring secure webhook processing.
-- **State Management with Redis**: The abstraction for managing installation states in Redis can be adapted for other applications needing similar state persistence.
-- **Azure Function Setup**: The setup and deployment scripts for Azure Functions provide a template for other serverless applications.
-
-This summary provides a high-level understanding of the Complianz app's architecture and implementation, highlighting key patterns and integrations that can be leveraged in similar applications.