@seeka-labs/cli-apps 3.8.8 → 3.9.1

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

@@ -1,152 +0,0 @@
-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

@@ -1,106 +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';
-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

@@ -1,41 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,21 +0,0 @@
-{
-  "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

@@ -1,25 +0,0 @@
-{
-  "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

@@ -1,24 +0,0 @@
-{
-  "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

@@ -1,8 +0,0 @@
-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

@@ -1,31 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# AI Summary for Navitas App
-
-## Purpose and Functionality
-The Navitas app is designed to integrate with the Navitas education group for tracking student inquiries and conversions. It serves as a CRM tool and browser plugin to manage and monitor educational leads effectively. The app facilitates communication between Salesforce and Navitas systems, ensuring seamless data exchange and integration.
-
-## Key Implementation Patterns
-- **Monorepo Structure**: The app utilizes a monorepo setup managed by Yarn workspaces. This allows for efficient management of multiple packages (`app/*` and `lib/*`) within the project.
-- **Azure Functions**: The server-side logic is implemented using Azure Functions, providing a scalable and serverless environment for handling HTTP requests.
-- **Webhook Handling**: The app processes various webhook events such as app installation, settings updates, and uninstallation. It validates webhook signatures to ensure secure communication.
-- **Logging**: The app employs the `winston` library for logging, with specific loggers for different components to maintain detailed logs of operations and errors.
-
-## External APIs/Services Integrated
-- **Salesforce**: The app integrates with Salesforce via outbound messages, allowing it to receive data in XML format. Specific headers like `Content-Length` or `Transfer-Encoding` are required for these messages.
-- **Google BigQuery**: The app interacts with BigQuery for data storage and analysis. It uses specific naming conventions (`seekacd_`, `seekacd-`, `stream-activity-`) for functions, views, and tables that are managed by Seeka's continuous delivery pipelines.
-
-## Important Data Transformations
-- **Webhook Payload Processing**: The app processes incoming webhook payloads, transforming them into actionable data. This includes creating or updating installation states and managing permissions and settings.
-- **Installation State Management**: The app maintains the state of installations, including permissions granted, installation settings, and timestamps, ensuring data consistency across different webhook events.
-
-## Notable Code Patterns
-- **Webhook Signature Validation**: The app includes a robust mechanism to validate webhook signatures using a secret key, ensuring that only legitimate requests are processed.
-- **Error Handling and Logging**: Comprehensive error handling is implemented with detailed logging to capture exceptions and operational profiles, aiding in debugging and monitoring.
-- **Service Initialization**: The `startServices` function is used to initialize necessary services before processing webhook events, ensuring that all dependencies are ready for operation.
-
-This summary provides an overview of the Navitas app's architecture and functionality, highlighting key patterns and integrations that can be referenced for similar implementations.

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

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

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

@@ -1,33 +0,0 @@
-{
-  "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

@@ -1,12 +0,0 @@
-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);
-};