@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/app/services/google/customers.ts

@@ -0,0 +1,301 @@
+import { Logger } from "winston";
+import { getGoogleAdsClient, GoogleAdsClientInfo } from "./ads";
+import {
+    DetailedGoogleAdsCustomerInfo,
+    GoogleAdsAppInstallContext,
+    GoogleAdsCustomerInfo
+} from "@seeka-labs-apps/google-ads-lib";
+
+/** Normalizes any Google Ads resource name or numeric to plain string ID */
+const normalizeCustomerId = (val: string | number | undefined | null): string | null => {
+    if (val == null) return null;
+    const s = String(val);
+    if (s.includes("/")) {
+        // e.g. "customers/1234567890" -> "1234567890"
+        const parts = s.split("/");
+        return parts[parts.length - 1] || null;
+    }
+    return s;
+};
+
+/**
+ * Enumerate immediate child accounts (level = 1) for a single MCC.
+ * Only returns children that are ALSO present in `accessibleIds`.
+ */
+export const listImmediateChildAccountsFor = async (
+    mccId: string,
+    deps: GoogleAdsClientInfo,
+    accessibleIds: string[],
+    logger: Logger
+): Promise<GoogleAdsCustomerInfo[]> => {
+    const { client, token } = deps;
+
+    const customer = client.Customer({
+        customer_id: mccId,
+        refresh_token: token.refresh_token,
+    });
+
+    try {
+        // https://developers.google.com/google-ads/api/fields/v21/customer_client
+        const rows = await customer.query(`
+      SELECT
+        customer_client.client_customer,
+        customer_client.descriptive_name,
+        customer_client.level,
+        customer_client.manager
+      FROM customer_client
+      WHERE customer_client.level = 1
+            AND customer_client.status = ENABLED    
+            AND customer_client.hidden = FALSE    
+            AND customer_client.test_account = FALSE  
+    `);
+
+        logger.debug("Loaded customer_client MCC child rows", {
+            mccId,
+            rows,
+        });
+
+        const children: GoogleAdsCustomerInfo[] = [];
+
+        for (const r of rows) {
+            const childId = normalizeCustomerId(r.customer_client.client_customer);
+            if (!childId) continue;
+
+            // keep ONLY children that are accessible to the user
+            if (accessibleIds.indexOf(childId)) {
+                children.push({
+                    customerId: childId,
+                    customerName: r.customer_client.descriptive_name ?? childId,
+                    // Keep isManager if your lib type supports it, otherwise remove this line.
+                    isManager: !!r.customer_client.manager,
+                    children: [], // hydrate so the parent push works cleanly
+                } as GoogleAdsCustomerInfo);
+            }
+            // else {
+            //     logger.debug(`Child ${childId} is not accessible to the user`, { accessibleIds, customer: r });
+            // }
+        }
+
+        return children;
+    } catch (err) {
+        logger.warn(`Failed to fetch children for manager ${mccId}`, err as Error);
+        return [];
+    }
+};
+
+export const getAccessibleCustomers = async (
+    includeChildCustomers: boolean,
+    installation: GoogleAdsAppInstallContext,
+    logger: Logger
+): Promise<GoogleAdsCustomerInfo[]> => {
+    // 1) Core client + refresh token
+    const googleAds = await getGoogleAdsClient(installation, logger);
+    const refreshToken = googleAds.token.refresh_token as string;
+
+    // 2) Pull the resource names we can access
+    const { resource_names: resourceNames } = await googleAds.client.listAccessibleCustomers(refreshToken);
+
+    // logger.debug("Loaded accessible customers", { resourceNames });
+
+    const accessibleIds = resourceNames.map((rn) => normalizeCustomerId(rn));
+    // logger.debug("Loaded accessibleIds", { accessibleIds: JSON.stringify(accessibleIds) });
+
+    // 3) Fetch basics (name + manager flag) for each accessible account
+
+    // https://developers.google.com/google-ads/api/fields/v21/customer
+    const basicsResults = await Promise.all(
+        accessibleIds.map(async (customerId) => {
+            const customer = googleAds.client.Customer({ customer_id: customerId, refresh_token: refreshToken });
+            try {
+                const [row] = await customer.query(`
+          SELECT
+            customer.id,
+            customer.descriptive_name,
+            customer.manager
+          FROM customer
+            WHERE customer.status = ENABLED    
+            AND customer.test_account = FALSE  
+          LIMIT 1
+        `);
+
+                return {
+                    customerId: normalizeCustomerId(row.customer.id)!,
+                    customerName: row.customer.descriptive_name,
+                    // Keep isManager if your lib type supports it, otherwise remove this line.
+                    isManager: !!row.customer.manager,
+                    children: [], // pre-hydrate so we can push into it
+                } as GoogleAdsCustomerInfo;
+            } catch (err) {
+                logger.warn(`Failed to fetch basics for customer ${customerId}`, err as Error);
+                return null;
+            }
+        })
+    );
+
+    const basics = basicsResults.filter((x): x is GoogleAdsCustomerInfo => x !== null);
+
+    // 4) Build a map of base nodes
+    const nodes = new Map<string, GoogleAdsCustomerInfo>();
+    for (const b of basics) {
+        nodes.set(b.customerId, { ...b }); // children already []
+    }
+
+    // Track parent relation to find roots later
+    const parentOf = new Map<string, string>(); // childId -> parentId
+
+    // 5) If requested, enumerate immediate children for each manager and attach
+    if (includeChildCustomers) {
+        await Promise.all(
+            basics
+                .filter((b) => (b as any).isManager) // if your type lacks isManager, replace with a separate lookup
+                .map(async (mgr) => {
+                    const children = await listImmediateChildAccountsFor(mgr.customerId, googleAds, accessibleIds, logger);
+
+                    for (const child of children) {
+                        // Ensure a node exists for the child (prefer the one already in nodes to preserve name/isManager)
+                        if (!nodes.has(child.customerId)) {
+                            nodes.set(child.customerId, child);
+                        } else {
+                            // merge in name if missing (defensive)
+                            const existing = nodes.get(child.customerId)!;
+                            if (!existing.customerName && child.customerName) {
+                                existing.customerName = child.customerName;
+                            }
+                        }
+
+                        // Avoid re-parenting if already attached under another accessible MCC
+                        if (!parentOf.has(child.customerId)) {
+                            const parentNode = nodes.get(mgr.customerId)!;
+                            const childNode = nodes.get(child.customerId)!;
+                            parentNode.children = parentNode.children ?? [];
+                            parentNode.children.push(childNode);
+                            parentOf.set(child.customerId, mgr.customerId);
+                        }
+                    }
+                })
+        );
+    }
+
+    // 6) Roots are those with no parent inside the accessible set.
+    // logger.debug("Loaded customer_client MCC child nodes", {
+    //     nodes: nodes,
+    //     parentLinks: parentOf.size,
+    // });
+
+    const roots: GoogleAdsCustomerInfo[] = [];
+    for (const [id, node] of nodes.entries()) {
+        if (!parentOf.has(id)) {
+            // normalize empty arrays to undefined for cleanliness
+            if (!includeChildCustomers && node.children && node.children.length === 0) {
+                delete (node as any).children;
+            }
+            roots.push(node);
+        }
+    }
+
+    // Sort roots and the entire tree
+    const byName = (a: GoogleAdsCustomerInfo, b: GoogleAdsCustomerInfo) =>
+        a.customerName.localeCompare(b.customerName, undefined, { sensitivity: "base" });
+
+    const sortTree = (n: GoogleAdsCustomerInfo) => {
+        if (n.children && n.children.length) {
+            n.children.sort(byName);
+            n.children.forEach(sortTree);
+        }
+    };
+
+    roots.sort(byName);
+    roots.forEach(sortTree);
+
+    // 6) Roots are those with no parent inside the accessible set.
+    // logger.debug("Loaded customer_client MCC child roots", {
+    //     roots: roots,
+    // });
+
+    return roots;
+};
+
+export const getGoogleAdsCustomerInfo = async (
+    customerId: string,
+    rootCustomerId: string,
+    installation: GoogleAdsAppInstallContext,
+    logger: Logger
+): Promise<DetailedGoogleAdsCustomerInfo | null> => {
+    const { client, token } = await getGoogleAdsClient(installation, logger);
+    const refreshToken = token.refresh_token as string;
+
+    const customer = client.Customer({
+        customer_id: customerId,
+        login_customer_id: rootCustomerId || undefined,
+        refresh_token: refreshToken,
+    });
+
+    logger.info("Getting customer info", { customerId, rootCustomerId });
+
+    try {
+        // MCC or standard customer query
+        //     const query = rootCustomerId
+        //         ? `
+        //   SELECT
+        //     customer_client.client_customer,
+        //     customer_client.level,
+        //     customer_client.manager,
+        //     customer_client.descriptive_name,
+        //     customer_client.currency_code,
+        //     customer_client.time_zone,
+        //     customer_client.id
+        //   FROM customer_client
+        //   WHERE customer_client.id = ${customerId}
+        // `
+        //         : `
+        //   SELECT
+        //     customer.id,
+        //     customer.descriptive_name,
+        //     customer.conversion_tracking_setting.accepted_customer_data_terms,
+        //     customer.conversion_tracking_setting.google_ads_conversion_customer,
+        //     customer.conversion_tracking_setting.conversion_tracking_status,
+        //     customer.conversion_tracking_setting.conversion_tracking_id,
+        //     customer.conversion_tracking_setting.cross_account_conversion_tracking_id,
+        //     customer.conversion_tracking_setting.enhanced_conversions_for_leads_enabled,
+        //     customer.manager
+        //   FROM customer
+        //   LIMIT 1
+        // `;
+
+        //     const [row] = await customer.query(query);
+
+        // https://developers.google.com/google-ads/api/reference/rpc/v21/Customer
+        const [row] = await customer.query(`
+      SELECT
+        customer.id,
+        customer.descriptive_name,
+        customer.conversion_tracking_setting.accepted_customer_data_terms,
+        customer.conversion_tracking_setting.google_ads_conversion_customer,
+        customer.conversion_tracking_setting.conversion_tracking_status,
+        customer.conversion_tracking_setting.conversion_tracking_id,
+        customer.conversion_tracking_setting.cross_account_conversion_tracking_id,
+        customer.conversion_tracking_setting.enhanced_conversions_for_leads_enabled,
+        customer.manager
+      FROM customer
+      LIMIT 1
+    `);
+
+        return {
+            customerId,
+            customerName: row.customer.descriptive_name,
+            customerDataTermsAccepted: row.customer.conversion_tracking_setting.accepted_customer_data_terms,
+            googleAdsConversionCustomer: row.customer.conversion_tracking_setting.google_ads_conversion_customer,
+            enhancedConversionsForLeadsEnabled:
+                row.customer.conversion_tracking_setting.enhanced_conversions_for_leads_enabled,
+            enhancedConversionsEnabled: false,
+            // Keep isManager if your lib type supports it, otherwise remove this line.
+            isManager: !!row.customer.manager,
+            conversionTrackingId: row.customer.conversion_tracking_setting.conversion_tracking_id,
+            crossAccountConversionTrackingId:
+                row.customer.conversion_tracking_setting.cross_account_conversion_tracking_id,
+        };
+    } catch (err) {
+        logger.error(`Error fetching info for customer ${customerId}:`, err);
+        return null;
+    }
+};

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/app/services/google/queues/models.ts

@@ -0,0 +1,16 @@
+import { SeekaActivityAcceptedWebhookContent, SeekaActivityAcceptedWebhookPayload } from "@seeka-labs/sdk-apps-server"
+import {BackgroundJobRequestContext} from "@seeka-labs/sdk-apps-server-host";
+import {SeekaActivityToGoogleConversionActionMapping} from "@seeka-labs-apps/google-ads-lib";
+
+export interface TrackSeekaGoogleAdsConversionPayload {
+    seekaActivity: SeekaActivityAcceptedWebhookContent
+    mapping: SeekaActivityToGoogleConversionActionMapping
+}
+
+export interface TrackGoogleAdsConversionQueueItem extends BackgroundJobRequestContext<TrackSeekaGoogleAdsConversionPayload> {
+
+}
+
+export interface LegacyMediateSeekaActivityQueueItem extends BackgroundJobRequestContext<SeekaActivityAcceptedWebhookPayload> {
+
+}

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/functions/googleAuthCallback.ts

@@ -0,0 +1,133 @@
+import '../app/logging'
+import winston from "winston";
+
+import {app, HttpRequest, HttpResponseInit, InvocationContext} from '@azure/functions';
+
+import {appAccessTokenQueryParamName, coreApiAccessTokenQueryParamName} from '@seeka-labs/sdk-apps-core';
+import {decryptText} from '@seeka-labs/sdk-apps-server';
+import {
+    AppApiAuthInfo,
+    checkAuth,
+    childLogger, createOrUpdateInstallation,
+    startServices,
+    tryGetInstallation
+} from "@seeka-labs/sdk-apps-server-host";
+import {GoogleAdsCustomerInfo} from "@seeka-labs-apps/google-ads-lib";
+import {googleScopes, handleGoogleAuthCallback} from "../app/services/google/auth";
+import {getAccessibleCustomers} from "../app/services/google/customers";
+
+app.http('googleAuthCallback', {
+    methods: ['GET'],
+    authLevel: 'anonymous',
+    route: 'api/auth/callback/google',
+    handler: googleAuthCallback
+});
+
+export async function googleAuthCallback(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    let logger = childLogger({requestId: context.invocationId, url: req.url});
+    logger.profile('http.google.auth.callback')
+    logger.verbose('Received auth callback from Google', {url: req.url});
+
+    await startServices(logger)
+
+    // Validate redirect    
+    const reqUrl = new URL(req.url);
+    let state: AppApiAuthInfo;
+    let accessToken: string;
+    try {
+        accessToken = decryptText(reqUrl.searchParams.get('state') as string, process.env.DATA_ENCRYPTION_KEY as string);
+        // state = JSON.parse(decryptText(reqUrl.searchParams.get('state') as string, process.env.DATA_ENCRYPTION_KEY as string));
+        const authInfo = await checkAuth(accessToken, null, undefined, logger);
+        if (!authInfo) {
+            return {
+                status: 403,
+                jsonBody: {error: "Invalid request"}
+            }
+        }
+        state = authInfo;
+    } catch (err) {
+        logger.error('Failed to decrypt state', {ex: winston.exceptions.getAllInfo(err)});
+        return {
+            status: 403,
+            jsonBody: {error: "Invalid request"}
+        }
+    }
+    const {seekaAppId, seekaAppInstallId}: { seekaAppId: string, seekaAppInstallId: string } = state;
+
+    logger = childLogger({requestId: context.invocationId, url: req.url, seekaAppInstallId}, null, logger);
+    if (seekaAppId != process.env.SEEKA_APP_ID) {
+        return {
+            status: 422,
+            jsonBody: {error: "App ID invalid"}
+        }
+    }
+
+    await startServices(logger);
+
+    // Check if the request is for an app we have installed
+    const installation = await tryGetInstallation(seekaAppInstallId as string, false, logger);
+    if (installation == null) {
+        logger.warn('Request cannot be processed as the installation ID is not known by this app', {url: req.url});
+
+        return {
+            status: 422,
+            jsonBody: {error: "App not installed"}
+        }
+    }
+
+    logger = childLogger(null, installation, logger);
+
+    let accessibleCustomers: GoogleAdsCustomerInfo[] = [];
+    try {
+        logger.info('Handling Google auth callback', {url: req.url});
+
+        // Ensure correct scopes
+        const scopes = reqUrl.searchParams.get('scope')?.split(' ');
+
+        if (!scopes || !googleScopes.every(scope => scopes.includes(scope))) {
+            logger.warn('Invalid scopes', {scopes});
+
+            // Redirect to the app with query string error
+            return {
+                status: 302,
+                headers: {'Location': `${process.env.SELF_HOST_BASEURL}/app?error=invalid_scopes&${appAccessTokenQueryParamName}=${state.appAccessToken}&${coreApiAccessTokenQueryParamName}=${state.coreApiAccessToken}`}
+            }
+        }
+
+        // const redirectUrl = createRedirectUrl();
+        let installation = await handleGoogleAuthCallback(seekaAppInstallId, reqUrl, logger);
+
+        accessibleCustomers = (await getAccessibleCustomers(true, installation, logger));
+        installation.installationState.googleAdsAvailableCustomers = accessibleCustomers;
+
+        installation = await createOrUpdateInstallation(installation, logger);
+
+        // await maintainWebhooks(installation, false, logger);
+    } catch (err) {
+        logger.error('Failed to handle Google auth callback', {ex: winston.exceptions.getAllInfo(err)});
+        return {
+            status: 500,
+            jsonBody: {error: "Install failed"}
+        }
+    } finally {
+        logger.profile('http.google.auth.callback')
+        logger.verbose('Google auth callback handled');
+    }
+
+    return {
+        status: 200,
+        body: `
+        <html>
+        <head>
+        <script>window.close()</script>
+        </head>
+        <body></body>
+        </html>
+        `,
+        headers: {
+            "Content-Type": "text/html"
+        }
+        // status: 302,
+        // headers: { 'Location': `${process.env.SELF_HOST_BASEURL}/app?${appAccessTokenQueryParamName}=${state.appAccessToken}&${coreApiAccessTokenQueryParamName}=${state.coreApiAccessToken}` }
+    }
+}

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/functions/googleAuthRedirect.ts

@@ -0,0 +1,69 @@
+import '../app/logging'
+import * as winston from 'winston';
+
+import {app, HttpRequest, HttpResponseInit, InvocationContext} from '@azure/functions';
+import {childLogger, getAccessTokenAndCheck, startServices, tryGetInstallation} from "@seeka-labs/sdk-apps-server-host";
+import {getAuthUrl} from "../app/services/google/auth";
+
+app.http('googleAuthRedirect', {
+    methods: ['GET'],
+    authLevel: 'anonymous',
+    route: 'api/auth/redirect/google',
+    handler: googleAuthRedirect
+});
+
+export async function googleAuthRedirect(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    let logger = childLogger({requestId: context.invocationId, url: req.url});
+    logger.profile('http.google.auth.redirect')
+    logger.verbose('Received auth redirect from Google', {url: req.url});
+
+    const authInfo = await getAccessTokenAndCheck(req.url, req.headers, startServices, logger);
+    if (!authInfo) {
+        return {
+            status: 403,
+            jsonBody: {error: "Invalid request"}
+        }
+    }
+    const {seekaAppId, seekaAppInstallId} = authInfo;
+
+    logger = childLogger({requestId: context.invocationId, url: req.url, seekaAppInstallId});
+    if (seekaAppId != process.env.SEEKA_APP_ID) {
+        return {
+            status: 422,
+            jsonBody: {error: "App ID invalid"}
+        }
+    }
+
+    // Check if the request is for an app we have installed
+    const installation = await tryGetInstallation(seekaAppInstallId as string, false, logger);
+    if (installation == null) {
+        logger.warn('Request cannot be processed as the installation ID is not known by this app ', {url: req.url});
+
+        return {
+            status: 422,
+            jsonBody: {error: "App not installed"}
+        }
+    }
+
+    logger = childLogger(null, installation, logger);
+
+    try {
+        logger.info('Handling Google auth redirect', {url: req.url});
+
+        const url = await getAuthUrl(seekaAppId, seekaAppInstallId, authInfo.appAccessToken, logger);
+
+        return {
+            status: 302,
+            headers: {'Location': url}
+        }
+    } catch (err) {
+        logger.error('Failed to handle Google auth redirect', {ex: winston.exceptions.getAllInfo(err)});
+        return {
+            status: 500,
+            jsonBody: {error: "Install failed"}
+        }
+    } finally {
+        logger.profile('http.google.auth.redirect')
+        logger.verbose('Google auth redirect handled');
+    }
+}

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/functions/healthCheck.ts

@@ -0,0 +1,20 @@
+import '../app/logging'
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+import { appLogger } from "@seeka-labs/sdk-apps-server-host";
+
+app.http('healthCheck', {
+    methods: ['GET', 'HEAD'],
+    authLevel: 'anonymous',
+    route: 'api/health',
+    handler: healthCheck
+});
+
+export async function healthCheck(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    // logger.verbose('Health check request received', { status: res.status, url: req.url });
+    appLogger.verbose('Health check', { url: req.url });
+
+    return {
+        status: 200
+    }
+}

package/dist/ai-context/internal/examples/v3/google-ads/app/server/src/functions/legacyMediateSeekaActivityQueueHandler.ts

@@ -0,0 +1,46 @@
+import '../app/logging'
+import * as winston from 'winston';
+
+import {app, InvocationContext} from '@azure/functions';
+import {deserialiseQueuePayload, queueNames, sendQueueMessageToPoisonQueue} from "../app/jobs";
+import {LegacyMediateSeekaActivityQueueItem} from "../app/services/google/queues/models";
+import {backgroundJobLogger, childLogger, startServices, tryGetInstallation} from "@seeka-labs/sdk-apps-server-host";
+import {legacyMediateSeekaActivity} from "../app/services/google/conversions/mediate";
+
+app.storageQueue('legacyMediateSeekaActivityQueueHandler', {
+    queueName: queueNames.legacyMediateSeekaActivity,
+    connection: 'AzureWebJobsStorage',
+    handler: legacyMediateSeekaActivityQueueHandler
+});
+
+export async function legacyMediateSeekaActivityQueueHandler(queueItem: unknown, context: InvocationContext): Promise<void> {
+    const body = typeof queueItem === 'string' ? deserialiseQueuePayload<LegacyMediateSeekaActivityQueueItem>(queueItem) : queueItem as LegacyMediateSeekaActivityQueueItem;
+    let logger = backgroundJobLogger(queueNames.legacyMediateSeekaActivity, body, context);
+    logger.profile(`queue.${queueNames.legacyMediateSeekaActivity}`)
+
+    await startServices(logger);
+
+    const installation = await tryGetInstallation(body.applicationInstallId as string, true, logger);
+
+    logger = childLogger({
+        'Activity_ActivityIdentifier': body?.payload?.content?.activity?.activityId,
+        'Tracking_Source_Url': body?.payload?.content?.source?.loc,
+        'Activity_Name': body?.payload?.content?.activity?.activityNameCustom || body?.payload?.content?.activity?.activityName?.toString()
+    }, installation, logger)
+
+    logger.verbose('Received request to mediate seeka activity queue item', {body});
+
+    try {
+        await legacyMediateSeekaActivity(body, installation, context, logger);
+    } catch (err) {
+        logger.error('Error handling mediate seeka activity queue item', {ex: winston.exceptions.getAllInfo(err)})
+
+        await sendQueueMessageToPoisonQueue(queueNames.legacyMediateSeekaActivity, {
+            payload: body.payload,
+            causationId: body.causationId,
+            correlationId: context.invocationId,
+        } as LegacyMediateSeekaActivityQueueItem, logger);
+    }
+
+    logger.profile(`queue.${queueNames.legacyMediateSeekaActivity}`)
+}