@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v2/klaviyo-events/app/server/src/lib/klaviyo/utils/index.ts

@@ -0,0 +1,152 @@
+import { SeekaActivityAcceptedWebhookPayload, TrackingActivityNames, WebsiteEventActivityAppsPayload } from "@seeka-labs/sdk-apps-server";
+import { EventCreateQueryV2 } from "klaviyo-api";
+import { isNil, lowerCase, omitBy, sumBy, upperFirst } from "lodash-es";
+import { Logger } from 'winston';
+
+export const seekaActivityToKlaviyoEvent = (payload: SeekaActivityAcceptedWebhookPayload, logger: Logger): EventCreateQueryV2 | null => {
+    const activity = payload.content.activity;
+    const identity = payload.content.identifiers;
+
+    const eventName = getKlaviyoEventName(activity);
+    if (!eventName) {
+        logger.debug("Seeka activity name not supported")
+        return null;
+    }
+
+    const klaviyoProfileIdArr = identity.klaviyo?.data[payload.context.organisationBrandId]?.profileId?.filter(e => Boolean(e));
+    let klaviyoProfileId = ''
+    if (!klaviyoProfileIdArr || klaviyoProfileIdArr.length === 0) {
+        logger.warn("No Klaviyo profile ID found", {
+            brandId: payload.context.organisationBrandId,
+            klaviyoIdentity: identity.klaviyo?.data
+        })
+    }
+    else {
+        klaviyoProfileId = klaviyoProfileIdArr[0]
+    }
+
+    let email = identity.email && identity.email.length > 0 ? identity.email[0] : null;
+    let phoneNumber = identity.phone && identity.phone.length > 0 ? identity.phone[0] : null;
+
+    if (!email && !phoneNumber && !klaviyoProfileId) {
+        logger.debug("No phone, email or klaviyo profile ID on seeka identity. Not sending event to Klaviyo")
+        return null;
+    }
+
+    const value = activity.commerce?.totalPrice || activity.lead?.predictedLtv || activity.lead?.predictedValue || activity.contentItem?.value;
+    const valueCurrency = activity.commerce?.currencyCode || activity.lead?.currencyCode || activity.lead?.currencyCode || activity.contentItem?.currencyCode;
+    // const orderId
+
+    let commerceProp = { ...activity.commerce }
+    if (Object.keys(commerceProp).length === 1 && (!commerceProp.products || commerceProp.products.length === 0)) {
+        commerceProp = null
+    }
+
+    let eventExtraProps = omitBy({
+        commerce: commerceProp,
+        contentBehaviour: activity.contentBehaviour,
+        contentItem: activity.contentItem,
+        lead: activity.lead,
+        promotion: activity.promotion,
+        search: activity.search,
+        signUp: activity.signUp,
+        userAccount: activity.userAccount,
+    }, (a) => {
+        if (isNil(a)) return true;
+        if ((a as any).length === 0 || Object.keys(a).length === 0) return true;
+
+        return false;
+    })
+
+    let eventProps: any = {}
+    if (activity.contentItem?.categoryName) {
+        eventProps.categoryName = activity.contentItem?.categoryName;
+    }
+    if (activity.contentItem?.contentName) {
+        eventProps.contentName = activity.contentItem?.contentName;
+    }
+    if (activity.lead?.sourceContentName) {
+        eventProps.contentName = activity.lead?.sourceContentName;
+    }
+    if (activity.commerce?.orderIdentifier) {
+        eventProps.orderIdentifier = activity.commerce?.orderIdentifier;
+    }
+    if (activity.commerce?.checkoutIdentifier) {
+        eventProps.checkoutIdentifier = activity.commerce?.checkoutIdentifier;
+    }
+    if (activity.commerce?.orderNumber) {
+        eventProps.orderNumber = activity.commerce?.orderNumber;
+    }
+    if (activity.commerce?.customerIdentifier) {
+        eventProps.customerIdentifier = activity.commerce?.customerIdentifier;
+    }
+    if (activity.commerce?.products && activity.commerce?.products.length > 0) {
+        eventProps["Item Count"] = sumBy(activity.commerce.products, e => e.quantity)
+        eventProps["Items"] = activity.commerce.products.map(e => e.sku || e.productIdentifier || e.variantIdentifier).filter(Boolean)
+        eventProps["skus"] = activity.commerce.products.map(e => e.sku).filter(Boolean)
+        eventProps["productIdentifiers"] = activity.commerce.products.map(e => e.productIdentifier).filter(Boolean)
+        eventProps["productNames"] = activity.commerce.products.map(e => e.productName).filter(Boolean)
+        eventProps["variantIdentifiers"] = activity.commerce.products.map(e => e.variantIdentifier).filter(Boolean)
+        eventProps["variantNames"] = activity.commerce.products.map(e => e.variantName).filter(Boolean)
+    }
+    eventProps = omitBy(eventProps, (a) => {
+        if (isNil(a)) return true;
+        if ((a as any).length === 0 || Object.keys(a).length === 0) return true;
+
+        return false;
+    })
+
+    return {
+        data: {
+            type: 'event',
+            attributes: {
+                uniqueId: activity.activityId,
+                time: activity.time,
+                value,
+                valueCurrency,
+                properties: {
+                    ...eventProps,
+                    $extra: eventExtraProps,
+                },
+                profile: {
+                    data: {
+                        type: "profile",
+                        id: klaviyoProfileId,
+                        attributes: {
+                            email,
+                            phoneNumber,
+                            externalId: identity.seekaPId,
+                            properties: {
+                                seekaPersonId: identity.seekaPId // prop name matches C# klaviyo profiles integration
+                            }
+                        }
+                    }
+                },
+                metric: {
+                    data: {
+                        type: 'metric',
+                        attributes: {
+                            name: eventName
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+const humaniseText = str => upperFirst(lowerCase(str));
+
+const getKlaviyoEventName = (activity: WebsiteEventActivityAppsPayload): string | null => {
+    switch (activity.activityName) {
+        case TrackingActivityNames.Custom: return humaniseText(activity.activityNameCustom);
+        // case TrackingActivityNames.InitiateCheckout: return 'Checkout Started';
+        // case TrackingActivityNames.Order: return 'Placed Order';
+        // case TrackingActivityNames.AddToCart: return 'Added to Cart';
+        // case TrackingActivityNames.Lead: return 'Lead form submitted';
+        // case TrackingActivityNames.ViewProduct: return 'Viewed Product';
+        // case TrackingActivityNames.ViewContentItem: return 'Viewed content';
+        // default: return null;
+        default: return humaniseText(activity.activityName);
+    }
+}

package/dist/ai-context/internal/examples/v2/klaviyo-events/app/server/src/lib/logging/index.ts

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

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

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

package/dist/ai-context/internal/examples/v2/klaviyo-events/app/server/src/lib/state/redis/index.ts

@@ -0,0 +1,102 @@
+import { createClient, RedisClientType } from 'redis';
+
+import * as winston from 'winston';
+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}`;
+
+export const createNewClient = (): RedisClientType => {
+    const c = createClient({
+        url: redisConn,
+        disableClientInfo: true,
+
+    })
+        .on('error', (err) => logger.error('Redis Client ', { ex: winston.exceptions.getAllInfo(err) }));
+
+    return c as RedisClientType
+}
+
+const redisClient = createNewClient()
+
+export const connect = async () => {
+    await redisClient.connect();
+}
+
+export const isConnected = () => {
+    return redisClient.isOpen;
+}
+
+export const disconnect = async () => {
+    await redisClient.destroy();
+}
+
+const getKeyPrefix = (stateType: string) => `seeka:app:${process.env.SEEKA_APP_ID}:${stateType}`
+export const getKey = (stateType: string, key: string) => `${getKeyPrefix(stateType)}:${key}`
+
+export async function getOrCreate<TState>(stateType: string, key: string, toCreate: TState, mode: 'string' | 'json' = 'string'): Promise<TState> {
+    const fullKey = getKey(stateType, key);
+    const existingStr = await getString(redisClient, fullKey);
+    if (existingStr) return JSON.parse(existingStr);
+
+    if (mode === 'json') {
+        await redisClient.json.set(fullKey, '$', toCreate as never);
+    }
+    else {
+        await redisClient.set(fullKey, JSON.stringify(toCreate));
+    }
+
+    return toCreate;
+}
+
+export async function tryGet<TState>(stateType: string, key: string, mode: 'string' | 'json' = 'string'): Promise<TState | null> {
+    const fullKey = getKey(stateType, key);
+
+    if (mode === 'json') {
+        const existing = await redisClient.json.get(fullKey);
+        if (existing) return existing as TState;
+    }
+    else {
+        const existingStr = await getString(redisClient, 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, mode: 'string' | 'json' = 'string'): Promise<void> {
+    const fullKey = getKey(stateType, key);
+
+    if (mode === 'json') {
+        await redisClient.json.set(fullKey, '$', toCreate as never);
+    }
+    else {
+        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);
+}
+
+async function getString(redisClient: any, key: string): Promise<string> {
+    const result = await redisClient.get(key);
+    if (typeof result === 'string') {
+        return result;
+    }
+    if (result) {
+        return result.toString();
+    }
+    return '';
+}

package/dist/ai-context/internal/examples/v2/klaviyo-events/app/server/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: KlaviyoEventsAppInstallSettings
+    // State relating to the app and installation of the app
+    installationState: KlaviyoEventsAppInstallState;
+
+    // When the app was installed
+    installedAt: string; // new Date().toISOString()
+}
+
+export interface KlaviyoEventsAppInstallState {
+    grantedPermissions?: string[]
+}
+
+export type KlaviyoEventsAppInstallSettings = {
+    privateApiKey?: string
+}
+
+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/v2/klaviyo-events/app/server/tsconfig.json

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

package/dist/ai-context/internal/examples/v2/klaviyo-events/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "root",
+  "version": "2.0.2",
+  "private": true,
+  "workspaces": [
+    "app/*"
+  ],
+  "scripts": {
+    "build": "yarn workspace @seeka-app-klaviyo-events/server run build",
+    "clean": "yarn workspaces foreach --all -pt run clean",
+    "lint": "yarn workspaces foreach --all -pt run lint",
+    "dev": "yarn workspace @seeka-app-klaviyo-events/server run dev",
+    "deploy": "yarn workspace @seeka-app-klaviyo-events/server run deploy",
+    "tunnel": "yarn workspace @seeka-app-klaviyo-events/server run tunnel",
+    "bump:patch": "yarn git:isclean && yarn workspaces foreach --all version patch --deferred && yarn bump:apply && yarn git:push",
+    "bump:minor": "yarn git:isclean && yarn workspaces foreach --all version minor --deferred && yarn bump:apply && yarn git:push",
+    "bump:major": "yarn git:isclean && yarn workspaces foreach --all version major --deferred && yarn bump:apply && yarn git:push",
+    "bump:apply": "yarn version apply --all",
+    "git:isclean": "bash -c 'if [ -n \"$(git status --porcelain)\" ]; then echo \"✖ Working directory not clean. Commit or stash your changes first.\"; exit 1; fi'",
+    "git:push": "git add -A && git commit -m \"v$(node -p \"require('./package.json').version\")\" && git tag -a v$(node -p \"require('./package.json').version\") -m \"v$(node -p \"require('./package.json').version\")\"",
+    "clean:all": "yarn lerna clean --yes && yarn clean && yarn nx reset && rimraf node_modules",
+    "dev:kill": "taskkill /f /t /im node.exe"
+  },
+  "packageManager": "yarn@4.9.1"
+}

package/dist/ai-context/internal/examples/v2/klaviyo-events/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": false,
+    "esModuleInterop": true,
+    "sourceMap": true,
+    "module": "CommonJS",
+    "target": "ES6",
+    "resolveJsonModule": true,
+    "isolatedModules": false,
+    "baseUrl": ".",
+    "paths": {
+      "@seeka-app-webhook/*": ["app/*/src"]
+    }
+  },
+  "references": [
+    { "path": "app/server" }
+  ],
+  "exclude": [
+    "node_modules",
+    "**/dist"
+  ]
+}

package/dist/ai-context/internal/examples/v2/navitas/.yarnrc.yml

@@ -0,0 +1,8 @@
+nodeLinker: node-modules
+                          
+nmHoistingLimits: workspaces
+
+npmScopes: 
+  seeka-labs: 
+    npmRegistryServer: "https://npm.packages.seeka.services"
+    npmAuthToken: "YqwHeBKR8vi37iclBehBwD5TfXx4LEbp2BHdqrbDkMSd/ZBGunsn9EwT9bfjjiMD"

package/dist/ai-context/internal/examples/v2/navitas/README.md

@@ -0,0 +1,31 @@
+# Navitas app
+
+Onboarding doc - https://docs.google.com/document/d/1l-GBsmvvc8GkKntAWY0YvCg-7Vsw6DqybBtEEkiy0CQ/edit?tab=t.0
+
+# updating all deps
+```
+cd repo root
+npx npm-check-updates@latest -i --target minor --workspaces && npx npm-check-updates@latest -i --target latest --workspaces
+```
+
+## Instructions for Salesforce developers
+
+Outbound message: 
+
+POST with XML content type
+
+Headers:
+Content-Length request header must be set
+OR set Transfer-Encoding request header to 'chunked'
+
+URLS:
+ACAP:
+https://apps.seeka.services/navitas/api/webhook/salesforce?appInstallId=5fd93708-eb56-73a3-e1b3-3a134b8e7de1&code=<functions key>
+
+SAE: 
+https://apps.seeka.services/navitas/api/webhook/salesforce?appInstallId=3bbf3a53-b77a-ff65-2862-3a134071e783&code=<functions key>
+
+## Instructions for Navitas BigQuery data cloud engineers
+- Do not modify any BigQuery functions prefaced with `seekacd_`. These are automatically maintained by Seeka continuous delivery pipelines
+- Do not modify any BigQuery views or tables prefaced with `seekacd-`. These are automatically maintained by Seeka continuous delivery pipelines
+- Do not modify any BigQuery tables prefaced with `stream-activity-`. These are automatically maintained by Seeka continuous delivery pipelines

package/dist/ai-context/internal/examples/v2/navitas/_ai-summary.md

@@ -0,0 +1,39 @@
+# AI Summary for Navitas App
+
+## Overview
+
+The Navitas app is designed to integrate with the Navitas education group, focusing on tracking student inquiries and conversions. It serves as a bridge between educational lead tracking and CRM systems, providing a seamless way to manage student data and interactions. The app includes both browser and server components, leveraging Azure Functions for server-side operations.
+
+## Key Implementation Patterns
+
+1. **Monorepo Structure**: The app uses a monorepo setup with Yarn workspaces, organizing code into separate packages for the browser and server components, as well as a shared library for Google BigQuery interactions.
+
+2. **Webhook Handling**: The app extensively uses webhooks to manage events such as app installation, settings updates, and uninstallation. The webhook handler validates incoming requests, processes them based on their type, and logs the operations for auditing and debugging.
+
+3. **Continuous Delivery**: The app employs continuous delivery pipelines to automatically maintain certain BigQuery functions, views, and tables, ensuring that the data infrastructure remains consistent and up-to-date.
+
+## External APIs/Services Integrated
+
+1. **Azure Functions**: The server component is built using Azure Functions, providing a scalable and efficient way to handle HTTP requests and background tasks.
+
+2. **Salesforce**: The app integrates with Salesforce via outbound messages, requiring specific headers and XML content types for communication.
+
+3. **Google BigQuery**: The app interacts with BigQuery for data storage and analysis, with specific instructions to avoid modifying certain auto-managed resources.
+
+## Important Data Transformations
+
+- **Webhook Payload Processing**: Incoming webhook payloads are parsed and validated to ensure authenticity and integrity. The app processes different types of webhook calls, transforming them into actions such as creating or updating installations, or handling browser SDK plugin requests.
+
+- **Installation State Management**: The app manages installation states by creating or updating records with details such as granted permissions, installation IDs, and organizational information.
+
+## Notable Code Patterns
+
+1. **Logger Utilization**: The app uses the `winston` library for logging, providing detailed insights into webhook handling and error management. This pattern can be reused for robust logging in other applications.
+
+2. **Environment Variable Usage**: Secure handling of sensitive information, such as webhook secrets, is achieved through environment variables, ensuring that these details are not hardcoded into the source code.
+
+3. **Error Handling and Profiling**: The app includes comprehensive error handling and profiling for webhook requests, allowing for efficient debugging and performance monitoring.
+
+4. **Version Management**: The app includes scripts for managing version bumps (patch, minor, major) across all workspaces, ensuring consistent versioning and deployment practices.
+
+This summary provides a high-level understanding of the Navitas app's architecture, integrations, and key implementation details, which can be referenced for developing similar applications or enhancing existing ones.

package/dist/ai-context/internal/examples/v2/navitas/app/browser/README.md

@@ -0,0 +1 @@
+# `@seeka-labs/seeka-app-navitas-browser`

package/dist/ai-context/internal/examples/v2/navitas/app/browser/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@seeka-app-navitas/browser",
+  "version": "2.2.13",
+  "description": "Seeka browser app seeka-app-navitas-browser",
+  "author": "Seeka company <support@seeka.co>",
+  "license": "MIT",
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "lint": "eslint --fix src/ --ext .ts",
+    "clean": "rimraf dist build package",
+    "build": "yarn clean && node ./scripts/esbuild/build-browser-plugin.mjs seeka-app-navitas NavitasConvergeSdkPlugin",
+    "build:dev": "yarn clean && node ./scripts/esbuild/build-browser-plugin.mjs seeka-app-navitas NavitasConvergeSdkPlugin dev",
+    "watch": "yarn clean && node ./scripts/esbuild/build-browser-plugin.mjs seeka-app-navitas NavitasConvergeSdkPlugin dev watch"
+  },
+  "dependencies": {
+    "@seeka-labs/converge": "^1.9.8"
+  },
+  "devDependencies": {
+    "@jgoz/esbuild-plugin-typecheck": "^4.0.3",
+    "@types/lodash-es": "^4.17.12",
+    "@types/node": "^20",
+    "@typescript-eslint/eslint-plugin": "^8.44.0",
+    "@typescript-eslint/parser": "^8.44.0",
+    "esbuild": "^0.25.10",
+    "eslint": "^9",
+    "eslint-plugin-unused-imports": "^4.2.0",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3",
+    "watch": "^1.0.2"
+  }
+}

package/dist/ai-context/internal/examples/v2/navitas/app/browser/src/browser.ts

@@ -0,0 +1,12 @@
+import type { INavitasBrowserSdkPluginConfig } from '../../server/src/lib/models';
+import { NavitasConvergeSdkPlugin } from "./plugin";
+
+declare global {
+  interface Window {
+    NavitasConvergeSdkPlugin: (pluginConfig: INavitasBrowserSdkPluginConfig) => NavitasConvergeSdkPlugin;
+  }
+}
+
+(window as Window).NavitasConvergeSdkPlugin = (pluginConfig: INavitasBrowserSdkPluginConfig) => {
+  return new NavitasConvergeSdkPlugin(pluginConfig);
+};