@seeka-labs/cli-apps 3.8.7 → 3.8.10

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

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

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

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

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

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