@seeka-labs/cli-apps 3.8.7 → 3.8.10

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

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

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

@@ -1,153 +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 { 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

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

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

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