@seeka-labs/cli-apps 3.8.8 → 3.9.1

package/dist/ai-context/internal/examples/v2/clarity/app/server/src/functions/seekaAppWebhook.ts

@@ -1,163 +0,0 @@
-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, 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
-    try {
-        switch (body.type) {
-            case SeekaWebhookCallType.AppInstalled:
-                {
-                    await onInstallation(body as SeekaAppInstalledWebhookPayload, logger);
-                    break;
-                }
-            case SeekaWebhookCallType.AppInstallSettingsUpdated:
-                {
-                    await onInstallationSettingsUpdate(body as SeekaAppInstallSettingsUpdatedWebhookPayload, logger);
-                    break;
-                }
-            case SeekaWebhookCallType.AppUninstalled:
-                {
-                    if (!body.isTest) {
-                        const payload = body as SeekaAppUninstalledWebhookPayload;
-                        await deleteInstallation(payload.context?.applicationInstallId as string, logger)
-                    }
-                    break;
-                }
-            case SeekaWebhookCallType.BrowserSdkPlugin: {
-                const plugin = await getSeekaBrowserPlugin(installation as SeekaAppInstallState, logger);
-
-                logger.profile('http.seeka.webhook.app')
-                return {
-                    status: 200,
-                    body: JSON.stringify(plugin),
-                    headers: {
-                        'Content-Type': 'application/json'
-                    }
-                }
-            }
-        }
-    }
-    catch (err) {
-        logger.error('Failed to handle webhook', { ex: winston.exceptions.getAllInfo(err) });
-        return {
-            status: 500,
-            jsonBody: { error: "Request failed" }
-        }
-    }
-    finally {
-        logger.profile('http.seeka.webhook.app')
-        logger.verbose('Seeka webhook handled');
-    }
-
-    return {
-        status: 204
-    }
-}
-
-const onInstallation = async (payload: SeekaAppInstalledWebhookPayload, logger: Logger) => {
-    if (payload.isTest) return;
-
-    const installation = await createOrUpdateInstallation({
-        ...payload.context,
-        installationState: {
-            grantedPermissions: payload.content?.grantedPermissions || []
-        },
-        applicationInstallId: payload.context?.applicationInstallId as string,
-        organisationBrandId: payload.context?.organisationBrandId as string,
-        organisationId: payload.context?.organisationId as string,
-        installedAt: new Date().toISOString(),
-        installationSettings: payload.content?.installationSettings || {}
-    }, logger)
-}
-
-const onInstallationSettingsUpdate = async (payload: SeekaAppInstallSettingsUpdatedWebhookPayload, logger: Logger) => {
-    if (payload.isTest) return;
-
-    const existingInstallation = await tryGetInstallation(payload.context?.applicationInstallId as string, true, logger) as SeekaAppInstallState;
-    const installation = await createOrUpdateInstallation({
-        ...existingInstallation,
-        installationState: {
-            ...existingInstallation.installationState,
-            grantedPermissions: payload.content?.grantedPermissions || []
-        },
-        installationSettings: payload.content?.installationSettings || {},
-    }, logger)
-}

package/dist/ai-context/internal/examples/v2/clarity/app/server/src/lib/browser/index.ts

@@ -1,54 +0,0 @@
-import { SeekaBrowserSdkPluginWebhookResponse } from '@seeka-labs/sdk-apps-server';
-import fs from 'fs';
-import path from 'path';
-import util from 'util';
-import winston, { Logger } from 'winston';
-import type { IClarityAppBrowserSdkPluginConfig } from '../models';
-import {
-    SeekaAppInstallState
-} from '../state/seeka/installations';
-
-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-clarity.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 = {
-                clarityProjectId: installation.installationSettings.clarityProjectId,
-                appId: process.env.SEEKA_APP_ID,
-                appInstallId: installation.applicationInstallId,
-                appUrl: process.env.SELF_HOST_BASEURL
-            } as IClarityAppBrowserSdkPluginConfig;
-            init = `ClarityAppConvergeSdkPlugin(${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/v2/clarity/app/server/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,
-        })
-    )
-}
-
-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/v2/clarity/app/server/src/lib/models/index.ts

@@ -1,6 +0,0 @@
-export interface IClarityAppBrowserSdkPluginConfig {
-    clarityProjectId: string | undefined;
-    appId: string
-    appInstallId: string
-    appUrl: string
-}

package/dist/ai-context/internal/examples/v2/clarity/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/clarity/app/server/src/lib/state/redis/index.ts

@@ -1,96 +0,0 @@
-import { createClient } from 'redis';
-
-import 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}`;
-
-const redisClient = createClient({
-    url: redisConn,
-    disableClientInfo: true,
-
-})
-    .on('error', (err) => 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.destroy();
-}
-
-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, 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/clarity/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: ClarityAppInstallSettings
-    // State relating to the app and installation of the app
-    installationState: ClarityAppInstallState;
-
-    // When the app was installed
-    installedAt: string; // new Date().toISOString()
-}
-
-export interface ClarityAppInstallState {
-    grantedPermissions?: string[]
-}
-
-export type ClarityAppInstallSettings = { [key: string]: any; } | {
-    clarityProjectId: string | undefined;
-}
-
-const stateType = 'install'
-
-export const tryGetInstallation = async (applicationInstallId: string, throwWhenNotFound: boolean, logger: Logger): Promise<SeekaAppInstallState | null> => {
-    const installation = await tryGet<SeekaAppInstallState>(stateType, applicationInstallId);
-    if (installation == null && throwWhenNotFound) {
-        throw new Error(`Seeka installation ${applicationInstallId} not found`);
-    }
-
-    return installation;
-}
-
-export const listInstallations = async (logger: Logger): Promise<SeekaAppInstallState[]> => {
-    const installations = await getList<SeekaAppInstallState>(stateType);
-
-    return installations;
-}
-
-
-export const createOrUpdateInstallation = async (state: SeekaAppInstallState, logger: Logger): Promise<SeekaAppInstallState> => {
-    if (!state.installationState) state.installationState = {};
-    if (!state.installedAt) state.installedAt = new Date().toISOString();
-
-    const creating = (await tryGetInstallation(state.applicationInstallId, false, logger)) === null;
-
-    await set(stateType, state.applicationInstallId, state);
-
-    logger.info(creating ? 'Created installation state' : 'Updated installation state', { applicationInstallId: state.applicationInstallId, organisationId: state.organisationId, organisationBrandId: state.organisationBrandId });
-
-    return state;
-}
-
-export const deleteInstallation = async (applicationInstallId: string, logger: Logger): Promise<void> => {
-    await remove(stateType, applicationInstallId);
-
-    logger.info('Deleted installation state', { applicationInstallId });
-}

package/dist/ai-context/internal/examples/v2/clarity/app/server/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "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/v2/clarity/package.json

@@ -1,19 +0,0 @@
-{
-  "name": "root",
-  "version": "2.0.3",
-  "private": true,
-  "workspaces": [
-    "app/*"
-  ],
-  "scripts": {
-    "build": "yarn clean && yarn workspace @seeka-app-clarity/browser run build && yarn workspace @seeka-app-clarity/server run build",
-    "clean": "yarn workspaces foreach --all -pt run clean",
-    "lint": "yarn workspaces foreach --all -pt run lint",
-    "dev": "yarn workspace @seeka-app-clarity/browser run build:dev && yarn workspace @seeka-app-clarity/server run dev",
-    "deploy": "yarn workspace @seeka-app-clarity/server run deploy"
-  },
-  "devDependencies": {
-    "azure-functions-core-tools": "^4.x"
-  },
-  "packageManager": "yarn@4.9.1"
-}

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

@@ -1,25 +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-clarity/*": ["app/*/src"]
-    }
-  },
-  "references": [
-    { "path": "app/server" },
-    { "path": "app/browser" }
-  ],
-  "exclude": [
-    "node_modules",
-    "**/dist"
-  ]
-}

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

@@ -1,3 +0,0 @@
-nodeLinker: node-modules
-                          
-nmHoistingLimits: workspaces           

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

@@ -1,39 +0,0 @@
-# AI-Focused Summary for Google BigQuery Seeka App
-
-## Overview
-
-The **Google BigQuery Seeka App** is designed to integrate Seeka activity data with Google BigQuery. This integration facilitates the export of activity data for advanced analytics and reporting, leveraging BigQuery's powerful data processing capabilities.
-
-## Key Implementation Patterns
-
-1. **Azure Functions**: The app is built using the Azure Functions framework, which allows for serverless execution of code in response to HTTP requests. This is evident from the use of `app.http` to define an HTTP-triggered function.
-
-2. **Webhook Handling**: The app listens for various Seeka webhook events, such as app installation, uninstallation, and activity acceptance. These events are processed to manage installations and export data to BigQuery.
-
-3. **Logging and Monitoring**: The app uses `winston` for logging, which provides detailed logs for debugging and monitoring purposes. The logs include profiling and verbose logging for incoming webhooks.
-
-4. **Environment Configuration**: The app relies on environment variables for configuration, such as `SEEKA_APP_SECRET` for validating webhook signatures.
-
-## External APIs/Services Integrated
-
-- **Google BigQuery**: The app integrates with Google BigQuery to check dataset and table existence and to export activity data for analytics.
-- **Azure Functions**: Utilized for deploying serverless functions that handle HTTP requests and process webhook events.
-
-## Important Data Transformations
-
-- **Webhook Payload Processing**: The app processes JSON payloads from Seeka webhooks, validating signatures and extracting necessary information for further processing.
-- **Data Sanitization**: The app includes functions like `sanitiseBigQueryRecord` to prepare data for BigQuery, ensuring it meets schema requirements.
-
-## Notable Code Patterns
-
-- **Webhook Signature Validation**: The app includes a robust mechanism to validate webhook signatures using a shared secret, enhancing security.
-- **Conditional Processing Based on Webhook Type**: The app uses a switch-case structure to handle different types of webhook events, allowing for modular and organized processing logic.
-- **Service Initialization**: The `startServices` function is called to initialize necessary services before processing webhook events, ensuring all dependencies are ready.
-
-## Reusable Code Patterns
-
-- **Webhook Handling Framework**: The pattern of defining HTTP-triggered functions and processing webhook events can be reused in other serverless applications requiring similar integrations.
-- **Logging with Winston**: The structured logging approach using `winston` can be applied to other applications for consistent and detailed logging.
-- **Environment-Based Configuration**: The use of environment variables for configuration is a best practice that can be adopted in other applications for flexibility and security.
-
-This summary provides a comprehensive understanding of the Google BigQuery Seeka App's architecture and implementation, highlighting key patterns and integrations that can be referenced or reused in similar projects.