@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v2/typeform/app/server/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/v2/typeform/app/server/src/lib/state/seeka/installations.ts

@@ -0,0 +1,64 @@
+import type { Logger } from 'winston';
+
+import { TypeformAppInstallSettings, TypeformFormBinding, TypeformFormBindingWebhookBind } from '@seeka-app-typeform/lib';
+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: TypeformAppInstallSettings
+    // State relating to the app and installation of the app
+    installationState: TypeformAppInstallState;
+
+    // When the app was installed
+    installedAt: string; // new Date().toISOString()
+}
+
+export interface TypeformAppInstallState {
+    typeformAccessToken?: string;
+    grantedPermissions?: string[];
+    boundWebhooks?: TypeformFormBindingWebhookBind[];
+    formBindings?: TypeformFormBinding[]
+}
+
+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/typeform/app/server/src/lib/typeform/auth.ts

@@ -0,0 +1,108 @@
+import { Logger } from "winston";
+import { SeekaAppInstallState, createOrUpdateInstallation, tryGetInstallation } from "../state/seeka/installations";
+import fetch from 'node-fetch'
+import { decryptText, encryptText } from "@seeka-labs/sdk-apps-server";
+
+export const handleTypeformAuthCallback = async (seekaAppInstallId: string, oAuthCode: string, redirectUri: string, logger: Logger): Promise<SeekaAppInstallState> => {
+    let installation: SeekaAppInstallState | null = null;
+    installation = await tryGetInstallation(seekaAppInstallId as string, false, logger);
+    if (installation == null) {
+        logger.error('Auth callback cannot be processed as the installation ID is not known by this app', { seekaAppInstallId });
+
+        throw new Error('App not installed');
+    }
+
+    const token = await getInitialTypeformOAuthToken(oAuthCode, redirectUri, logger);
+
+    installation.installationState.typeformAccessToken = encryptText(JSON.stringify(token), process.env.DATA_ENCRYPTION_KEY as string);
+    return await createOrUpdateInstallation(installation, logger);
+}
+
+export const createRedirectUrl = (): string => {
+    return `${process.env.SELF_HOST_BASEURL}/api/auth/callback/typeform`;
+}
+
+export const typeformScopes = 'offline accounts:read forms:read webhooks:write webhooks:read workspaces:read';
+
+const getInitialTypeformOAuthToken = async (oAuthCode: string, redirectUri: string, logger: Logger): Promise<TypeformAccessToken> => {
+    const encodedParams = new URLSearchParams();
+    const now = Date.now();
+
+    const url = `https://api.typeform.com/oauth/token`;
+    encodedParams.set('grant_type', 'authorization_code');
+    encodedParams.set('code', oAuthCode);
+    encodedParams.set('client_id', process.env.TYPEFORM_CLIENT_ID);
+    encodedParams.set('client_secret', process.env.TYPEFORM_CLIENT_SECRET);
+    encodedParams.set('redirect_uri', redirectUri);
+
+    const options = {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        body: encodedParams.toString()
+    };
+
+    const res = await fetch(url, options);
+    const json = await res.json();
+    if (!json.access_token || !json.refresh_token) {
+        logger.error('Failed to get Typeform OAuth token', { json });
+        throw new Error('Failed to get Typeform OAuth token');
+    }
+
+    // Add the time the token was created
+    json.created_at = now;
+
+    return json as TypeformAccessToken;
+}
+
+export const getTypeformAccessToken = async (installation: SeekaAppInstallState, logger: Logger): Promise<TypeformAccessToken> => {
+    let token = JSON.parse(decryptText(installation.installationState.typeformAccessToken, process.env.DATA_ENCRYPTION_KEY as string)) as TypeformAccessToken;
+    if (token.expires_in < (Date.now() - token.created_at)) {
+        token = await refreshTypeformAccessToken(token.refresh_token, logger);
+        installation.installationState.typeformAccessToken = encryptText(JSON.stringify(token), process.env.DATA_ENCRYPTION_KEY as string);
+        await createOrUpdateInstallation(installation, logger);
+    }
+
+    return token;
+}
+
+const refreshTypeformAccessToken = async (refreshToken: string, logger: Logger): Promise<TypeformAccessToken> => {
+    const encodedParams = new URLSearchParams();
+    const now = Date.now();
+
+    const url = `https://api.typeform.com/oauth/token`;
+    encodedParams.set('grant_type', 'refresh_token');
+    encodedParams.set('refresh_token', refreshToken);
+    encodedParams.set('client_id', process.env.TYPEFORM_CLIENT_ID);
+    encodedParams.set('client_secret', process.env.TYPEFORM_CLIENT_SECRET);
+    encodedParams.set('scope', typeformScopes);
+
+    const options = {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        },
+        body: encodedParams.toString()
+    };
+
+    const res = await fetch(url, options);
+    const json = await res.json();
+    if (!json.access_token || !json.refresh_token) {
+        logger.error('Failed to refresh Typeform OAuth token', { json });
+        throw new Error('Failed to refresh Typeform OAuth token');
+    }
+
+    // Add the time the token was created
+    json.created_at = now;
+
+    return json as TypeformAccessToken;
+}
+
+export interface TypeformAccessToken {
+    token_type: string
+    expires_in: number
+    created_at: number
+    refresh_token: string
+    access_token: string
+}

package/dist/ai-context/internal/examples/v2/typeform/app/server/src/lib/typeform/forms.ts

@@ -0,0 +1,259 @@
+import { ActivityPayload, getActivityName, PersonIdentifiers, SeekaAppHelper, TrackingActivityNames, TrackingEventSourceOriginType } from "@seeka-labs/sdk-apps-server";
+import { Logger } from "winston";
+import { SeekaAppInstallState } from "../state/seeka/installations";
+import { TypeformAccessToken } from "./auth";
+import { TypeformWebhookBody, TypeformWebhookBodyAnswer, TypeformWebhookBodyField, TypeformWebhookBodyFormResponse } from "./models";
+
+export const getForm = async (formId: string, token: TypeformAccessToken, logger: Logger): Promise<TypeformForm | null> => {
+    const url = `https://api.typeform.com/forms/${formId}`;
+
+    const options = {
+        method: 'GET',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: 'Bearer ' + token.access_token
+        }
+    };
+    const res = await fetch(url, options);
+    if (res.status != 200) {
+        if (res.status === 404) return null;
+
+        logger.error('Failed to get Typeform form', { status: res.status, body: res.text(), headers: res.headers });
+        throw new Error('Failed to get Typeform form');
+    }
+    const json = (await res.json()) as TypeformForm;
+
+    return json;
+}
+
+type TypeformForm = any;
+
+export const handleTypeformFormResponseWebhook = async (body: TypeformWebhookBody, helper: SeekaAppHelper, installation: SeekaAppInstallState, logger: Logger) => {
+    const seekaIdentity = typeformSubmissionToSeekaIdentity(body.form_response, logger);
+
+    const thisLogger = logger.child({
+        Person_PersonId: seekaIdentity?.seekaPId
+    });
+
+    let shouldMergeIdentity = false;
+    switch (body.event_type) {
+        case 'form_response_partial':
+            {
+                if (seekaIdentity) {
+                    // Just enrich identity
+                    shouldMergeIdentity = true;
+                }
+                break;
+            }
+        case 'form_response':
+            {
+                const handled = await handleTypeformFormResponse(body, seekaIdentity, seekaIdentity.seekaPId, helper, installation, thisLogger);
+                if (!handled && seekaIdentity) {
+                    // Still merge identity
+                    shouldMergeIdentity = true;
+                }
+                break;
+            }
+    }
+
+    if (shouldMergeIdentity) {
+        await helper.api.mergeIdentity(seekaIdentity, {
+            origin: TrackingEventSourceOriginType.Server,
+        });
+    }
+}
+
+const handleTypeformFormResponse = async (body: TypeformWebhookBody, seekaIdentity: PersonIdentifiers | null, seekaPersonId: string | null, helper: SeekaAppHelper, installation: SeekaAppInstallState, logger: Logger): Promise<boolean> => {
+    // Get the binding of the form
+    const formId = body.form_response.form_id;
+    const formBinding = installation?.installationState?.formBindings.find(b => b.typeFormFormId === formId);
+    if (formBinding == null) {
+        logger.warn('Form binding not found', { formId });
+        return false;
+    }
+
+    const activityNameToTrack = formBinding.formSubmitEventName;
+    if (!activityNameToTrack) {
+        logger.warn('Activity name not set on binding', { formId });
+        return false;
+    }
+
+    // Parse activity name
+    let activityNameCustom: string | undefined = undefined;
+    const activityName = getActivityName(activityNameToTrack);
+    if (activityName == TrackingActivityNames.Custom) {
+        activityNameCustom = activityNameToTrack;
+    }
+
+    // Track activity
+    const completePayload: ActivityPayload = {
+        activityId: `calendly-formsubmit-${body.event_id}`,
+        activityName,
+        activityNameCustom,
+        properties: {}
+    };
+    if (seekaIdentity) {
+        logger.info('Tracking activity for typeform submission', { activityName, activityNameCustom, completePayload });
+        await helper.api.trackActivityForProfile(completePayload, seekaIdentity, {
+            origin: TrackingEventSourceOriginType.Server,
+        });
+        return true;
+    }
+    else if (seekaPersonId) {
+        logger.info('Tracking activity for typeform submission', { activityName, activityNameCustom, completePayload });
+        await helper.api.trackActivityForProfileId(completePayload, seekaPersonId, {
+            origin: TrackingEventSourceOriginType.Server,
+        });
+        return true;
+    }
+    else {
+        logger.warn('No identity or person ID found to track activity, not tracking', { body });
+        return false;
+    }
+}
+
+const typeformSubmissionToSeekaIdentity = (submission: TypeformWebhookBodyFormResponse, logger: Logger): PersonIdentifiers | null => {
+    const identity: PersonIdentifiers = {};
+    let populated = false;
+
+    // Person ID
+    const seekaPersonId = (submission.hidden as any)?.seeka_person_id || (submission.hidden as any)?.seeka_id;
+    if (!seekaPersonId) {
+        logger.warn('No Seeka Person ID found in Typeform submission', { submission });
+    }
+    else {
+        identity.seekaPId = seekaPersonId;
+    }
+
+    // Fbclid
+    const fbclid = (submission.hidden as any)?.fbclid;
+    if (fbclid) {
+        identity.facebook = {
+            fbc: fbclid
+        };
+        populated = true;
+    }
+    // gclid
+    const gclid = (submission.hidden as any)?.gclid;
+    if (gclid) {
+        identity.google = {
+            gclid: gclid
+        };
+        populated = true;
+    }
+    // ttclid
+    const ttclid = (submission.hidden as any)?.ttclid;
+    if (ttclid) {
+        identity.tiktok = {
+            ttclid: ttclid
+        };
+        populated = true;
+    }
+    // sccid
+    const sccid = (submission.hidden as any)?.sccid;
+    if (sccid) {
+        identity.snapchat = {
+            sccid: sccid
+        };
+        populated = true;
+    }
+
+    // Email
+    const emailFields = getFieldIdsFromTitles(['email'], submission.definition.fields || [], logger);
+    if (emailFields.length > 0) {
+        const emails = getAnswersFromFields(emailFields, submission.answers, logger);
+        if (emails.length > 0) {
+            identity.email = emails;
+            populated = true;
+        }
+    }
+    if (!identity.email || identity.email.length === 0) {
+        const emails = (submission.answers || []).filter(a => a.field.type === 'email').map(a => a.email).filter(Boolean);
+        if (emails.length > 0) {
+            identity.email = emails;
+            populated = true;
+        }
+    }
+
+    // First name
+    const firstNameFields = getFieldIdsFromTitles(['firstname', 'first name'], submission.definition.fields || [], logger);
+    if (firstNameFields.length > 0) {
+        const firstNames = getAnswersFromFields(firstNameFields, submission.answers, logger);
+        if (firstNames.length > 0) {
+            identity.firstName = firstNames;
+            populated = true;
+        }
+    }
+
+    // last name
+    const lastNameFields = getFieldIdsFromTitles(['lastname', 'last name'], submission.definition.fields || [], logger);
+    if (lastNameFields.length > 0) {
+        const lastNames = getAnswersFromFields(lastNameFields, submission.answers, logger);
+        if (lastNames.length > 0) {
+            identity.lastName = lastNames;
+            populated = true;
+        }
+    }
+
+    // phone number
+    const phoneFields = getFieldIdsFromTitles(['phone', 'mobile phone', 'phone number'], submission.definition.fields || [], logger);
+    if (phoneFields.length > 0) {
+        const phoneNumbers = getAnswersFromFields(phoneFields, submission.answers, logger);
+        if (phoneNumbers.length > 0) {
+            identity.phone = phoneNumbers;
+            populated = true;
+        }
+    }
+    if (!identity.phone || identity.phone.length === 0) {
+        const phones = (submission.answers || []).filter(a => a.field.type === 'phone_number').map(a => a.phone_number).filter(Boolean);
+        if (phones.length > 0) {
+            identity.phone = phones;
+            populated = true;
+        }
+    }
+
+    const thisLogger = logger.child({
+        Person_PersonId: identity?.seekaPId
+    });
+
+    if (populated) {
+        thisLogger.debug('Identifiers extracted from Typeform submission', { submission, identity });
+        return identity;
+    }
+    else {
+        thisLogger.warn('No identifiers found in Typeform submission', { submission });
+        return null;
+    }
+}
+
+const getFieldIdsFromTitles = (titles: string[], fields: TypeformWebhookBodyField[], logger: Logger): TypeformWebhookBodyField[] => {
+    const found = titles.map(title => {
+        const field = fields.find(f => f.title.toLowerCase().includes(title) || f.ref.toLowerCase() === title);
+        return field || null;
+    }).filter(Boolean);
+
+    // Distinct found by field id
+    const foundIds = found.map(f => f.id);
+    const foundDistinct = found.filter((f, i) => foundIds.indexOf(f.id) === i);
+
+    if (foundDistinct.length === 0) {
+        logger.warn('Fields not found found in Typeform submission', { titles, fields });
+    }
+
+    return foundDistinct;
+}
+
+const getAnswersFromFields = (fields: TypeformWebhookBodyField[], answers: TypeformWebhookBodyAnswer[], logger: Logger): string[] => {
+    if (fields.length === 0) return [];
+
+    const found = fields.map(field => {
+        const answer = answers.find(a => a.field.id === field.id);
+        return answer?.text || answer?.phone_number || answer?.email;
+    }).filter(Boolean) as string[];
+
+    if (found.length !== fields.length) {
+        logger.warn('Not all answers found in Typeform submission', { fields, answers });
+    }
+
+    return found;
+}

package/dist/ai-context/internal/examples/v2/typeform/app/server/src/lib/typeform/models.ts

@@ -0,0 +1,105 @@
+export interface TypeformWebhookBody {
+    event_id: string
+    event_type: 'form_response' | 'form_response_partial'
+    form_response: TypeformWebhookBodyFormResponse
+}
+
+export interface TypeformWebhookBodyFormResponse {
+    form_id: string
+    token: string
+    submitted_at: string
+    landed_at: string
+    calculated: TypeformWebhookBodyCalculated
+    variables: TypeformWebhookBodyVariable[]
+    hidden: TypeformWebhookBodyHidden
+    definition: TypeformWebhookBodyDefinition
+    answers: TypeformWebhookBodyAnswer[]
+    ending: TypeformWebhookBodyEnding2
+}
+
+export interface TypeformWebhookBodyCalculated {
+    score: number
+}
+
+export interface TypeformWebhookBodyVariable {
+    key: string
+    type: string
+    number?: number
+    text?: string
+}
+
+export interface TypeformWebhookBodyHidden {
+    user_id: string
+}
+
+export interface TypeformWebhookBodyDefinition {
+    id: string
+    title: string
+    fields: TypeformWebhookBodyField[]
+    endings: TypeformWebhookBodyEnding[]
+}
+
+export interface TypeformWebhookBodyField {
+    id: string
+    title: string
+    type: string
+    ref: string
+    allow_multiple_selections?: boolean
+    allow_other_choice?: boolean
+    choices?: TypeformWebhookBodyChoice[]
+    properties?: TypeformWebhookBodyProperties
+}
+
+export interface TypeformWebhookBodyChoice {
+    id: string
+    ref: string
+    label: string
+}
+
+export interface TypeformWebhookBodyProperties { }
+
+export interface TypeformWebhookBodyEnding {
+    id: string
+    ref: string
+    title: string
+    type: string
+    properties: TypeformWebhookBodyProperties2
+}
+
+export interface TypeformWebhookBodyProperties2 {
+    button_text: string
+    show_button: boolean
+    share_icons: boolean
+    button_mode: string
+}
+
+export interface TypeformWebhookBodyAnswer {
+    type: string
+    text?: string
+    field: TypeformWebhookBodyField2
+    email?: string
+    phone_number?: string
+    date?: string
+    choices?: TypeformWebhookBodyChoices
+    number?: number
+    boolean?: boolean
+    choice?: TypeformWebhookBodyChoice
+    url?: string
+}
+
+export interface TypeformWebhookBodyField2 {
+    id: string
+    type: string
+    ref?: string
+}
+
+export interface TypeformWebhookBodyChoices {
+    ids: string[]
+    labels: string[]
+    refs: string[]
+}
+
+export interface TypeformWebhookBodyEnding2 {
+    id: string
+    ref: string
+}