@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v1/sevenrooms/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/v1/sevenrooms/src/lib/state/seeka/installations.ts

@@ -0,0 +1,140 @@
+import type { Logger } from 'winston';
+
+import { getList, remove, set, tryGet } from '../redis';
+
+import { SevenRoomsAuthToken } from '../../sevenrooms/auth';
+import { hasSevenRoomsServerSideSettings } from '../../sevenrooms/helpers';
+import { SevenRoomsAppInstallAdvancedSettings, SevenRoomsAppInstallChargesSettings, SevenRoomsAppInstallClientSettings, SevenRoomsAppInstallConnectionSettings, SevenRoomsAppInstallEventSettings } from './models';
+
+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: SevenRoomsAppInstallSettings
+    // State relating to the app and installation of the app
+    installationState: SevenRoomsAppInstallState;
+
+    // When the app was installed
+    installedAt: string; // new Date().toISOString()
+}
+
+export interface SevenRoomsAppInstallState {
+    grantedPermissions?: string[]
+    sevenRoomsToken?: SevenRoomsAuthToken
+    sevenRoomsVenue?: {
+        currencyCode?: string
+    }
+}
+
+export type SevenRoomsAppInstallSettings = {
+    connection?: SevenRoomsAppInstallConnectionSettings
+    advanced?: SevenRoomsAppInstallAdvancedSettings
+    clients?: SevenRoomsAppInstallClientSettings
+    events?: SevenRoomsAppInstallEventSettings
+    charges?: SevenRoomsAppInstallChargesSettings
+}
+
+type SevenRoomsVenueMapping = {
+    appInstallId: string
+    venueGroupId: string
+    venueId: string
+}
+
+const stateType = 'install'
+const sevenRoomsVenueMappingStateType = 'sevenRoomsVenueMapping'
+
+const getVenueMappingKey = (venueGroupId: string, venueId: string) => `${venueGroupId}:${venueId}`
+
+export const tryGetInstallationMappingFromVenue = async (venueGroupId: string, venueId: string, throwWhenNotFound: boolean, logger: Logger): Promise<SevenRoomsVenueMapping | null> => {
+    // seeka:app:2d3e450b-bb88-485b-a16f-2ad42f2b2889:sevenRoomsVenueMapping:ahhzfnNldmVucm9vbXMtc2VjdXJlLWRlbW9yIQsSFG5pZ2h0bG9vcF9WZW51ZUdyb3VwGICA2PSOypMJDA:ahhzfnNldmVucm9vbXMtc2VjdXJlLWRlbW9yHAsSD25pZ2h0bG9vcF9WZW51ZRiAgNiC9eqOCAw
+    const key = getVenueMappingKey(venueGroupId, venueId);
+    const mapping = await tryGet<SevenRoomsVenueMapping | null>(sevenRoomsVenueMappingStateType, key);
+    if (mapping == null && throwWhenNotFound) {
+        throw new Error(`Seeka installation for ${venueId} venue and group ${venueGroupId} not found`);
+    }
+
+    return mapping;
+}
+
+export const setInstallationIdVenueMapping = async (venueGroupId: string, venueId: string, installationId: string, logger: Logger): Promise<void> => {
+    const key = getVenueMappingKey(venueGroupId, venueId);
+
+    const existing = await tryGetInstallationMappingFromVenue(venueGroupId, venueId, false, logger);
+    if (existing) {
+        if (existing.appInstallId === installationId && existing.venueGroupId === venueGroupId && existing.venueId === venueId) {
+            // Already exists
+            logger.verbose('Installation ID venue mapping already exists', { venueGroupId, venueId, installationId });
+            return;
+        }
+        else {
+            logger.error('Installation ID venue mapping already exists for a different installation id', { venueGroupId, venueId, installationId, existing });
+            throw new Error('Installation ID venue mapping already exists. Delete the old installation first')
+        }
+    }
+
+    logger.info('Setting installation ID venue mapping', { venueGroupId, venueId, installationId });
+
+    await set<SevenRoomsVenueMapping>(sevenRoomsVenueMappingStateType, key, {
+        appInstallId: installationId,
+        venueGroupId: venueGroupId,
+        venueId: venueId
+    });
+}
+
+
+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 deleteInstallation = async (applicationInstallId: string, logger: Logger): Promise<void> => {
+    const existing = await tryGetInstallation(applicationInstallId, true, logger);
+
+    if (hasSevenRoomsServerSideSettings(existing.installationSettings)) {
+        // Delete mapping
+        const venueMapping = await tryGetInstallationMappingFromVenue(existing.installationSettings.connection.sevenRoomsVenueGroupId, existing.installationSettings.connection.sevenRoomsVenueId, false, logger);
+        if (venueMapping) {
+            await remove(sevenRoomsVenueMappingStateType, getVenueMappingKey(existing.installationSettings.connection.sevenRoomsVenueGroupId, existing.installationSettings.connection.sevenRoomsVenueId));
+        }
+    }
+
+    await remove(stateType, applicationInstallId);
+
+    logger.info('Deleted installation state', { applicationInstallId });
+}
+
+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.installationSettings.advanced) state.installationSettings.advanced = {};
+    if (!state.installationSettings.clients) state.installationSettings.clients = {};
+    if (!state.installationSettings.connection) state.installationSettings.connection = {};
+    if (!state.installationSettings.events) state.installationSettings.events = {};
+
+    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 });
+
+    if (hasSevenRoomsServerSideSettings(state.installationSettings)) {
+        await setInstallationIdVenueMapping(state.installationSettings.connection.sevenRoomsVenueGroupId, state.installationSettings.connection.sevenRoomsVenueId, state.applicationInstallId, logger);
+    }
+
+    return state;
+}

package/dist/ai-context/internal/examples/v1/sevenrooms/src/lib/state/seeka/models.ts

@@ -0,0 +1,34 @@
+import { ActivityPipelineActivityFilter } from '@seeka-labs/sdk-apps-server'
+
+export type SevenRoomsAppInstallConnectionSettings = {
+    sevenRoomsVenueId?: string
+    sevenRoomsVenueGroupId?: string
+    sevenRoomsClientId?: string
+    sevenRoomsClientSecret?: string
+}
+
+export type SevenRoomsAppInstallAdvancedSettings = {
+    sevenRoomsApiHost?: string
+    maintainMarketingConsent?: boolean
+    allowUseOfSevenRoomsExternalId?: boolean
+    sevenRoomsVenueTimezone?: string
+}
+
+export type SevenRoomsAppInstallClientSettings = {
+    pushClientToSevenRoomsRules?: ActivityPipelineActivityFilter[]
+}
+
+export type SevenRoomsAppInstallEventSettings = SevenRoomsAppInstallEventSettingsTyped<string>
+
+export type SevenRoomsAppInstallEventSettingsTyped<TValue> = {
+    reservationBookingCreatedWithValueEventName?: TValue
+    reservationBookingCreatedZeroValueEventName?: TValue
+    reservationBookingArrivedWithValueEventName?: TValue
+    reservationBookingArrivedZeroValueEventName?: TValue
+    eventBookingCreatedWithValueEventName?: TValue
+    eventBookingCreatedZeroValueEventName?: TValue
+}
+
+export type SevenRoomsAppInstallChargesSettings = {
+    pushChargesToSevenRoomsRules?: ActivityPipelineActivityFilter[]
+}

package/dist/ai-context/internal/examples/v1/sevenrooms/tsconfig.json

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

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

@@ -0,0 +1,10 @@
+/* eslint-env node */
+module.exports = {
+    extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
+    parser: '@typescript-eslint/parser',
+    plugins: ['@typescript-eslint'],
+    root: true,
+    rules: {
+        "@typescript-eslint/no-unused-vars": "warn"
+    }
+};

package/dist/ai-context/internal/examples/v1/tradable-bits/README.md

@@ -0,0 +1,104 @@
+# 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-tradablebits.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-tradablebits
+    - 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. `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/tradable-bits/_ai-summary.md

@@ -0,0 +1,45 @@
+# AI Summary for Seeka App: Tradable Bits
+
+## Overview
+
+The **Tradable Bits** app is a Seeka integration designed to enhance fan engagement in the entertainment and sports sectors. It leverages Azure Functions to process webhooks and manage state, providing a scalable solution for marketing and fan interaction.
+
+## Purpose and Functionality
+
+- **Fan Engagement**: The app integrates with the Tradable Bits platform to facilitate fan interactions and engagement in entertainment and sports.
+- **Webhook Handling**: Processes inbound webhooks from Seeka, managing installations and updates.
+- **Azure Queue Management**: Utilizes Azure Storage Queues for handling asynchronous operations, ensuring efficient processing of long-running tasks.
+- **Health Monitoring**: Includes a health check endpoint to monitor the app's operational status.
+
+## Key Implementation Patterns
+
+- **Azure Functions**: The app is built using Azure Functions, providing a serverless architecture that scales with demand.
+- **Webhook Processing**: Implements robust webhook handling, including signature validation and installation management.
+- **State Management**: Uses Redis for managing app installations and state, with support for alternative providers.
+- **Centralized Logging**: Utilizes Winston for logging, with optional integration with Seq for advanced log management.
+
+## External APIs/Services Integrated
+
+- **Azure Storage**: For queue management and asynchronous task handling.
+- **Redis**: For state management, with optional Upstash integration for cloud-based Redis.
+- **Ngrok**: For exposing local development environments to the internet, facilitating testing and debugging.
+
+## Important Data Transformations
+
+- **Webhook Payloads**: Parses and validates JSON payloads from incoming webhooks, ensuring data integrity and security.
+- **Installation State**: Transforms installation data into a structured format for storage and retrieval in Redis.
+
+## Notable Code Patterns
+
+- **Webhook Signature Validation**: Ensures secure processing of webhooks by validating signatures against a secret key.
+- **Service Initialization**: Uses a `startServices` function to initialize necessary services before processing webhooks.
+- **Error Handling**: Implements comprehensive error handling and logging to capture and diagnose issues during webhook processing.
+- **Queue Example**: Demonstrates offloading tasks to Azure Storage Queues, a pattern that can be reused for other asynchronous operations.
+
+## Development and Deployment
+
+- **Local Development**: Supports local development with Docker and Azurite for emulating Azure Storage services.
+- **Continuous Deployment**: Includes scripts for building, deploying, and managing the app on Azure, with support for live URL exposure via Ngrok.
+- **Debugging**: Offers VSCode integration for debugging, with support for breakpoints and live testing.
+
+This summary provides a comprehensive understanding of the Tradable Bits app's architecture, functionality, and integration points, facilitating AI-driven insights and assistance in development and deployment scenarios.

package/dist/ai-context/internal/examples/v1/tradable-bits/host.json

@@ -0,0 +1,20 @@
+{
+  "version": "2.0",
+  "logging": {
+    "applicationInsights": {
+      "samplingSettings": {
+        "isEnabled": true,
+        "excludedTypes": "Request"
+      }
+    }
+  },
+  "functionTimeout": "00:10:00",
+  "extensionBundle": {
+    "id": "Microsoft.Azure.Functions.ExtensionBundle",
+    "version": "[4.*, 5.0.0)"
+  },
+  "concurrency": {
+    "dynamicConcurrencyEnabled": true,
+    "snapshotPersistenceEnabled": true
+  }
+}

package/dist/ai-context/internal/examples/v1/tradable-bits/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "seeka-app-tradablebits",
+  "version": "1.0.6",
+  "description": "Seeka app seeka-app-tradablebits",
+  "author": "Seeka company <support@seeka.co>",
+  "license": "MIT",
+  "main": "dist/src/functions/*.js",
+  "private": true,
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "lint": "eslint",
+    "build": "yarn clean && tsc && cd src/browser && yarn && yarn build && cd ../",
+    "watch": "cd src/browser && yarn && yarn build && cd ../ && tsc -w",
+    "clean": "yarn rimraf dist",
+    "prestart": "yarn clean && yarn build",
+    "dev": "yarn build && func start --port 7072",
+    "tunnel": "node scripts/ngrok.js seeka-app-tradablebits-localdev",
+    "deploy": "yarn clean && yarn build && func azure functionapp publish seeka-app-tradablebits --no-build --javascript"
+  },
+  "dependencies": {
+    "@azure/functions": "^4.6.0",
+    "@azure/storage-queue": "^12.25.0",
+    "@datalust/winston-seq": "^2.0.0",
+    "@seeka-labs/sdk-apps-server": "^1.1.26",
+    "axios": "^1.7.9",
+    "lodash": "^4.17.21",
+    "redis": "^4.7.0",
+    "winston": "^3.17.0"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.14",
+    "@types/node": "^20",
+    "@typescript-eslint/eslint-plugin": "^8.22.0",
+    "@typescript-eslint/parser": "^8.22.0",
+    "azure-functions-core-tools": "^4.x",
+    "eslint": "^9",
+    "ngrok": "^5.0.0-beta.2",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.7.3"
+  }
+}

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

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

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

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

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

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

package/dist/ai-context/internal/examples/v1/tradable-bits/src/functions/healthCheck.ts

@@ -0,0 +1,14 @@
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+app.http('healthCheck', {
+    methods: ['GET', 'HEAD'],
+    authLevel: 'anonymous',
+    route: 'health',
+    handler: healthCheck
+});
+
+export async function healthCheck(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    return {
+        status: 200
+    }
+}