@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v2/webhook/app/server/src/functions/inboundWebhook.ts

@@ -0,0 +1,133 @@
+import winston from 'winston';
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+import { childLogger } from '../lib/logging';
+
+import { queueNames, triggerBackgroundJob } from '../lib/jobs';
+import { startServices } from '../lib/services';
+import { tryGetInstallation } from '../lib/state/seeka/installations';
+import { InboundWebhookPayload } from '../lib/webhooks/models';
+
+app.http('inboundWebhook', {
+    methods: ['POST', 'GET'],
+    authLevel: 'anonymous',
+    route: 'api/webhook/in/{appInstallId}',
+    handler: inboundWebhook
+});
+
+export async function inboundWebhook(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    let logger = childLogger({ requestId: context.invocationId, url: req.url });
+    let bodyStr: string | null;
+
+    const contentType = req.headers.get('Content-Type')
+    if (!contentType || (contentType != 'application/json' && contentType != 'application/json; charset=utf-8' && contentType !== 'application/xml') || req.method !== 'POST') {
+        const errMessage = "Must be a POST request with Content-Type as 'application/json' or 'application/xml' or 'application/json; charset=utf-8'";
+        logger.warn('Failed to handle inbound webhook due to invalid request format', { url: req.url, contentType, headers: req.headers.keys(), reqMethod: req.method });
+
+        return {
+            status: 400,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: generateInboundWebhookResponseBody(false, errMessage)
+        }
+    }
+
+    try {
+
+        bodyStr = (await req.text()) as string;
+        if (!bodyStr) {
+            const errMessage = "Body missing. Ensure body is present and either specify the Content-Length request header OR set Transfer-Encoding request header to 'chunked'";
+
+            logger.warn('Failed to handle inbound webhook - body is missing', { url: req.url, headers: req.headers.keys() });
+
+            return {
+                status: 400,
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: generateInboundWebhookResponseBody(false, errMessage)
+            }
+        }
+
+        logger.verbose('Received inbound webhook', { bodyStr });
+        // const body = JSON.parse(bodyStr);
+
+        logger.profile('http.inbound.webhook')
+
+        let payload: InboundWebhookPayload<string> = {
+            body: bodyStr
+        };
+        // try {
+        //     payload = (await parser.parseStringPromise(bodyStr)) as InboundWebhookPayload<any>;
+        //     logger.verbose('Parsed inbound webhook', { payload });
+        // }
+        // catch (err) {
+        //     const winEx = winston.exceptions.getAllInfo(err)
+        //     logger.warn('Failed to parse inbound webhook XML', { ex: winEx, err: !winEx ? err?.toString() : undefined, bodyStr, url: req.url });
+        //     return {
+        //         status: 400,
+        //         headers: {
+        //             'Content-Type': 'application/json'
+        //         },
+        //         body: generateInboundWebhookResponseBody(false, (winEx as any)?.message?.toString().split('at error')[0] || "Invalid XML")
+        //     }
+        // }
+
+        await startServices(logger);
+
+        const installationId = req.params['appInstallId'];
+        const installation = await tryGetInstallation(installationId, false, logger);
+        if (installation == null) {
+            return {
+                status: 401,
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: generateInboundWebhookResponseBody(false, 'Invalid webhook URL')
+            }
+        }
+
+        logger = childLogger(null, installation, logger)
+
+        await triggerBackgroundJob(queueNames.handleInboundWebhookRequest, {
+            payload,
+            organisationBrandId: installation.organisationBrandId,
+            organisationId: installation.organisationId,
+            applicationInstallId: installation.applicationInstallId,
+            causationId: context.invocationId,
+            correlationId: context.invocationId
+        }, logger)
+    }
+    catch (err) {
+        const winEx = winston.exceptions.getAllInfo(err)
+        logger.error('Failed to handle inbound webhook', { ex: winEx, err: !winEx ? err?.toString() : undefined, bodyStr, url: req.url });
+        return {
+            status: 500,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: generateInboundWebhookResponseBody(false)
+        }
+    }
+    finally {
+        logger.profile('http.inbound.webhook')
+        logger.verbose('Inbound webhook handled');
+    }
+
+    return {
+        status: 200,
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: generateInboundWebhookResponseBody(true)
+    }
+}
+
+const generateInboundWebhookResponseBody = (ack: boolean, message?: string) => {
+    return JSON.stringify({
+        success: ack,
+        message: message
+    }, null, 1)
+}

package/dist/ai-context/internal/examples/v2/webhook/app/server/src/functions/inboundWebhookQueueHandler.ts

@@ -0,0 +1,45 @@
+import winston from 'winston';
+
+import { app, InvocationContext } from '@azure/functions';
+
+import { deserialiseQueuePayload, queueNames, sendQueueMessageToPoisonQueue } from '../lib/jobs';
+import { backgroundJobLogger, childLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import { tryGetInstallation } from '../lib/state/seeka/installations';
+import { handleInboundWebhook } from '../lib/webhooks';
+import { InboundWebhookPayloadQueueItem } from '../lib/webhooks/models';
+
+app.storageQueue('inboundWebhookQueueHandler', {
+    queueName: queueNames.handleInboundWebhookRequest,
+    connection: 'AzureWebJobsStorage',
+    handler: inboundWebhookQueueHandler
+});
+
+export async function inboundWebhookQueueHandler(queueItem: unknown, context: InvocationContext): Promise<void> {
+    const body = typeof queueItem === 'string' ? deserialiseQueuePayload<InboundWebhookPayloadQueueItem<string>>(queueItem) : queueItem as InboundWebhookPayloadQueueItem<string>;
+    let logger = backgroundJobLogger(queueNames.handleInboundWebhookRequest, body, context);
+    logger.profile(`queue.${queueNames.handleInboundWebhookRequest}`)
+
+    await startServices(logger);
+
+    const installation = await tryGetInstallation(body.applicationInstallId as string, true, logger);
+
+    logger = childLogger(null, installation, logger)
+
+    logger.verbose('Received request to handle inbound webhook request queue item', { body });
+
+    try {
+        await handleInboundWebhook(body, installation, logger);
+    }
+    catch (err) {
+        logger.error('Error handling inbound webhook request queue item', { ex: winston.exceptions.getAllInfo(err) })
+
+        await sendQueueMessageToPoisonQueue(queueNames.handleInboundWebhookRequest, {
+            payload: body.payload,
+            causationId: body.causationId,
+            correlationId: context.invocationId,
+        } as InboundWebhookPayloadQueueItem<string>, logger);
+    }
+
+    logger.profile(`queue.${queueNames.handleInboundWebhookRequest}`)
+}

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

@@ -0,0 +1,153 @@
+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 { childLogger, 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: 'api/webhook/seeka/app',
+    handler: seekaAppWebhook
+});
+
+export async function seekaAppWebhook(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    const bodyStr = (await req.text()) as string;
+    const body = JSON.parse(bodyStr) as SeekaWebhookPayload;
+
+    let 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" }
+            }
+        }
+    }
+
+    logger = childLogger(null, installation, logger)
+
+    // 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: {
+
+                logger.profile('http.seeka.webhook.app')
+                return {
+                    status: 404
+                }
+            }
+        }
+    }
+    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/webhook/app/server/src/functions/ui.ts

@@ -0,0 +1,176 @@
+import { app, Cookie, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+import { promises as fs } from 'fs';
+import path from 'path';
+import { childLogger } from '../lib/logging';
+
+import { appAccessTokenQueryParamName, coreApiAccessTokenQueryParamName, getAppAccessTokenCookieName, getCoreApiAccessTokenCookieName } from '@seeka-labs/sdk-apps-core';
+import { AppApiAuthInfo, getAccessTokenAndCheck } from '../lib/api/auth';
+import { setSampleState } from '../lib/api/routes/setSampleState';
+import { SeekaAppInstallState } from '../lib/state/seeka/installations';
+
+// Define your route and handler for the /ui path
+app.http('ui', {
+    methods: ['GET', 'HEAD', 'POST', 'DELETE'],
+    authLevel: 'anonymous',
+    route: 'app/{*route}',  // Wildcard route under /ui
+    handler: ui
+});
+
+// Helper function to get the file content
+async function getFileContent(filePath: string, encoding?: BufferEncoding | undefined): Promise<string | Buffer> {
+    return await fs.readFile(filePath, { encoding: encoding });
+}
+
+const configJsFileName = 'config.js'
+
+// Function to serve the React app under /app
+export async function ui(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    let logger = childLogger({ requestId: context.invocationId, url: req.url });
+    logger.profile('http.seeka.webhook.app.ui')
+
+    const reqUrl = new URL(req.url);
+    const requestedPath = reqUrl.pathname?.replace(/^\/app/, '') || '/';
+    logger.verbose('Received Seeka ui request', { requestedPath, url: req.url, method: req.method });
+
+    const buildPath = path.resolve('./dist/src/ui/build');
+    // const buildPath = path.join(__dirname, 'build');)
+
+    let seekaAppId: string = null;
+    let seekaAppInstallId: string = null;
+    logger = childLogger({ requestId: context.invocationId, url: req.url, seekaAppInstallId });
+
+    let installation: SeekaAppInstallState | undefined;
+    const additionalHeaders = {};
+    let setCookies: Cookie[] = [];
+    let authResult: AppApiAuthInfo | undefined;
+
+    const checkAuth = async (): Promise<HttpResponseInit | null> => {
+        // Check auth
+        authResult = await getAccessTokenAndCheck(req, logger);
+        if (!authResult) {
+            return {
+                status: 403,
+                jsonBody: { error: 'Invalid token' }
+            };
+        }
+        seekaAppId = authResult.seekaAppId;
+        seekaAppInstallId = authResult.seekaAppInstallId;
+        installation = authResult.installation;
+
+        logger = childLogger(null, installation, logger);
+
+        setCookies.push({ name: getAppAccessTokenCookieName(process.env.SEEKA_APP_ID), value: authResult.appAccessToken, httpOnly: true, secure: true, sameSite: 'None', expires: new Date(authResult.expiresAt * 1000) });
+        setCookies.push({ name: getCoreApiAccessTokenCookieName(process.env.SEEKA_APP_ID), value: authResult.coreApiAccessToken, httpOnly: true, secure: true, sameSite: 'None', expires: new Date(authResult.expiresAt * 1000) });
+        return null;
+    }
+    let filePath = path.join(buildPath, requestedPath);
+
+    let content: string | Buffer;
+    try {
+        if (requestedPath === ('/' + configJsFileName)) {
+            const authRes = await checkAuth();
+            if (authRes) return authRes;
+
+            // const errResponse = checkRequiredUrlParams(reqUrl);
+            // if (errResponse) return errResponse;
+
+            // Under no means should internal or private api keys be exposed to the client with below
+            // const creds = JSON.parse(process.env.GOOGLE_CLOUD_SERVICEACCOUNT_CREDS_JSON as string);
+            const basePathUri = process.env['APP_UI_BASE_PATH'] ? `${process.env['APP_UI_BASE_PATH']}` : ''
+            const appBaseUrl = `${process.env.SELF_HOST_BASEURL}${basePathUri}`
+            const browserAppSettings = {
+                seekaAppId: seekaAppId,
+                seekaAppInstallId: seekaAppInstallId,
+                organisationBrandId: installation?.organisationBrandId,
+                appBaseUrl,
+                inboundWebhookUrl: `${process.env.SELF_HOST_BASEURL}/api/webhook/in/${seekaAppInstallId}`,
+                state: {
+                    sampleInstallationState: installation.installationState.sampleInstallationState
+                }
+            };
+            content = `window.seekaAppConfig = ${JSON.stringify(browserAppSettings)}`
+        }
+
+        if (requestedPath.startsWith('/api')) {
+            const authRes = await checkAuth();
+            if (authRes) return authRes;
+
+            // Handle app api route
+            if (requestedPath === '/api/state/set/sample' && req.method === 'POST') return await setSampleState(installation, req, context, logger);
+
+            return {
+                status: 404,
+                jsonBody: { error: 'Not found' }
+            };
+        }
+
+        if (requestedPath === '/' || requestedPath === '/index.html') {
+            const authRes = await checkAuth();
+            if (authRes) return authRes;
+
+            // const errResponse = checkRequiredUrlParams(reqUrl);
+            // if (errResponse) return errResponse;
+
+            // Serve index.html for the root or when accessing directly
+            const tokenParams = `?${appAccessTokenQueryParamName}=${encodeURIComponent(authResult.appAccessToken)}`
+                + `&${coreApiAccessTokenQueryParamName}=${encodeURIComponent(authResult.coreApiAccessToken)}&`;
+
+            filePath = path.join(buildPath, 'index.html');
+            let html = (await getFileContent(filePath, 'utf-8')) as string;
+            html = html.replace(configJsFileName + '?', configJsFileName + tokenParams);
+            content = html;
+        } else {
+            // Resolve the requested file path
+            filePath = path.join(buildPath, requestedPath);
+            // Ensure the file exists, otherwise fallback to index.html (for client-side routing)
+            await fs.access(filePath);
+        }
+    } catch (err) {
+        // logger.error('Error trying to serve content', { ex: winston.exceptions.getAllInfo(err), requestedPath });
+        // console.log('File not found, serving index.html', err);
+        // filePath = path.join(buildPath, 'index.html');
+        filePath = path.join(buildPath, 'index.html');
+        console.log('File not found, serving index.html', { err, requestedPath, buildPath, filePath, content });
+    }
+
+    if (!content) {
+        content = await getFileContent(filePath);
+    }
+
+    const contentType = getContentType(filePath);
+
+    return {
+        status: 200,
+        headers: {
+            'Content-Type': contentType,
+            'Referrer-Policy': 'no-referrer',
+            ...additionalHeaders
+        },
+        cookies: setCookies,
+        body: content,
+    };
+}
+
+// const checkRequiredUrlParams = (reqUrl: URL): any | undefined => {
+//     const seekaAppId = reqUrl.searchParams.get('seekaAppId');
+//     if (seekaAppId != process.env.SEEKA_APP_ID) {
+//         console.log('App ID invalid', { url: reqUrl, seekaAppId, seekaAppIdEnv: process.env.SEEKA_APP_ID });
+//         return {
+//             status: 422,
+//             jsonBody: { error: "App ID invalid" }
+//         }
+//     }
+
+//     return undefined;
+// }
+
+// Function to determine the content type based on file extension
+function getContentType(filePath: string): string {
+    if (filePath.endsWith('.html')) return 'text/html';
+    if (filePath.endsWith('.js')) return 'application/javascript';
+    if (filePath.endsWith('.css')) return 'text/css';
+    if (filePath.endsWith('.png')) return 'image/png';
+    if (filePath.endsWith('.jpg') || filePath.endsWith('.jpeg')) return 'image/jpeg';
+    if (filePath.endsWith('.gif')) return 'image/gif';
+    return 'application/octet-stream';
+}

package/dist/ai-context/internal/examples/v2/webhook/app/server/src/lib/api/auth.ts

@@ -0,0 +1,91 @@
+import { HttpRequest } from "@azure/functions";
+import { appAccessTokenHeaderName, appAccessTokenQueryParamName, coreApiAccessTokenHeaderName, coreApiAccessTokenQueryParamName, getAppAccessTokenCookieName, getCoreApiAccessTokenCookieName } from "@seeka-labs/sdk-apps-core";
+import jwt from 'jsonwebtoken';
+import { Logger } from "winston";
+import { startServices } from '../services';
+import { SeekaAppInstallState, tryGetInstallation } from "../state/seeka/installations";
+
+
+export const getAccessTokenAndCheck = async (req: HttpRequest, logger: Logger): Promise<AppApiAuthInfo | undefined> => {
+    const reqUrl = new URL(req.url);
+
+    // Get access token from cookie
+    const cookies = req.headers.get('Cookie');
+    // logger.info('Cookie', cookies);
+    let accessToken: string = reqUrl.searchParams.get(appAccessTokenQueryParamName) || '';
+    if (!accessToken && req.headers.get(appAccessTokenHeaderName)) {
+        accessToken = req.headers.get(appAccessTokenHeaderName)?.split('Bearer ')[1];
+    }
+    if (!accessToken && cookies) {
+        const cookie = cookies.split(';').find(c => c.trim().startsWith(getAppAccessTokenCookieName(process.env.SEEKA_APP_ID)));
+        if (cookie) {
+            accessToken = cookie.split('=')[1];
+        }
+    }
+
+    let coreApiAccessToken: string = reqUrl.searchParams.get(coreApiAccessTokenQueryParamName) || '';
+    if (!coreApiAccessToken && req.headers.get(coreApiAccessTokenHeaderName)) {
+        coreApiAccessToken = req.headers.get(coreApiAccessTokenHeaderName)?.split('Bearer ')[1];
+    }
+    if (!coreApiAccessToken && cookies) {
+        const cookie = cookies.split(';').find(c => c.trim().startsWith(getCoreApiAccessTokenCookieName(process.env.SEEKA_APP_ID)));
+        if (cookie) {
+            coreApiAccessToken = cookie.split('=')[1];
+        }
+    }
+
+    // Validate access token
+    return await checkAuth(accessToken, coreApiAccessToken, true, logger);
+}
+
+export const checkAuth = async (appAccessToken: string, coreApiAccessToken: string, startAppServices: boolean, logger: Logger): Promise<AppApiAuthInfo | undefined> => {
+    let seekaAppId: string;
+    let seekaAppInstallId;
+    let expiresAt: number;
+
+    // Validate access token
+    if (appAccessToken) {
+        try {
+            const decoded = jwt.verify(appAccessToken, process.env['SEEKA_APP_SECRET'] as string, { ignoreNotBefore: true }) as jwt.JwtPayload;
+            logger.info('Decoded token', { decoded });
+            if (!decoded.appId || decoded.appId.replace(/-/g, '') !== process.env['SEEKA_APP_ID'].replace(/-/g, '') as string) {
+                logger.error('Invalid token - app id does not match', { decoded, appIdToken: decoded.appId, appIdEnv: process.env['SEEKA_APP_ID'] });
+                return undefined;
+            }
+            else {
+                seekaAppId = decoded.appId;
+            }
+            if (!decoded.appInstallId) {
+                logger.error('Invalid token - no appInstallId', { decoded });
+                return undefined;
+            }
+            else {
+                seekaAppInstallId = decoded.appInstallId;
+            }
+
+            expiresAt = decoded.exp as number;
+        }
+        catch (err) {
+            logger.error('Failed to validate token', { err });
+            return undefined;
+        }
+    }
+    else {
+        logger.error('No access token present');
+        return undefined;
+    }
+
+    // Check if the webhook is for an app we have installed    
+    if (startAppServices) {
+        await startServices(logger);
+    }
+    const installation = await tryGetInstallation(seekaAppInstallId, false, logger);
+    if (installation == null) {
+        logger.warn('UI call cannot be processed as the installation ID is not known by this app', { seekaAppInstallId });
+        return undefined;
+    }
+
+    return { appAccessToken, coreApiAccessToken, seekaAppId, seekaAppInstallId, expiresAt, installation };
+}
+
+export interface AppApiAuthInfo { appAccessToken: string, coreApiAccessToken: string, seekaAppId: string, seekaAppInstallId: string, expiresAt: number, installation: SeekaAppInstallState }

package/dist/ai-context/internal/examples/v2/webhook/app/server/src/lib/api/routes/setSampleState.ts

@@ -0,0 +1,25 @@
+import { HttpRequest, HttpResponseInit, InvocationContext } from "@azure/functions";
+import { Logger } from "winston";
+import { createOrUpdateInstallation, SeekaAppInstallState } from "../../state/seeka/installations";
+
+export const setSampleState = async (installation: SeekaAppInstallState, req: HttpRequest, context: InvocationContext, logger: Logger): Promise<HttpResponseInit> => {
+    // Validate
+    const body = (await req.json()) as any;
+    const sampleState = body.sampleState as string;
+    if (!sampleState) {
+        return {
+            status: 400,
+            jsonBody: { error: 'sampleState is required' }
+        };
+    }
+
+    installation.installationState = {
+        ...installation.installationState,
+        sampleInstallationState: sampleState,
+    };
+    await createOrUpdateInstallation(installation, logger);
+
+    return {
+        status: 200
+    };
+}