@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v2/yeastar/app/server/src/functions/ui.ts

@@ -0,0 +1,174 @@
+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 { getYeastarCrmConfig } from './../lib/api/routes/yeastar/config/getYeastarCrmConfig';
+
+import { appAccessTokenQueryParamName, coreApiAccessTokenQueryParamName, getAppAccessTokenCookieName, getCoreApiAccessTokenCookieName } from '@seeka-labs/sdk-apps-core';
+import { AppApiAuthInfo, getAccessTokenAndCheck } from '../lib/api/auth';
+import { setTrackingSettings } from '../lib/api/routes/setTrackingSettings';
+import { setYeastarUsers } from '../lib/api/routes/yeastar/users/setYeastarUsers';
+import { SeekaAppInstallState } from '../lib/state/seeka/installations';
+
+// Define your route and handler for the /ui path
+app.http('ui', {
+    methods: ['GET', 'HEAD', 'POST'],
+    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 });
+
+    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;
+
+        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.YEASTAR_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,
+                appBaseUrl,
+                state: {
+                    userMappings: installation.installationState?.yeastarUserMappings,
+                    trackingSettings: installation.installationState?.tracking,
+                }
+            };
+            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/settings/yeastar/config' && req.method === 'GET') return await getYeastarCrmConfig(installation, req, context, logger);
+            if (requestedPath === '/api/settings/yeastar/users/mappings' && req.method === 'POST') return await setYeastarUsers(installation, req, context, logger);
+            if (requestedPath === '/api/settings/yeastar/config/tracking' && req.method === 'POST') return await setTrackingSettings(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) {
+        console.log('File not found, serving index.html', err);
+        filePath = path.join(buildPath, 'index.html');
+    }
+
+    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/yeastar/app/server/src/functions/yeastarCallJournal.ts

@@ -0,0 +1,83 @@
+import * as winston from 'winston';
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+import { childLogger } from '../lib/logging';
+
+import { startServices } from '../lib/services';
+import { tryGetInstallation } from '../lib/state/seeka/installations';
+import { cleanYeastarCallJournalPayload, trackCallJournalLogInSeeka } from '../lib/yeastar/calls';
+
+
+app.http('yeastarCallJournal', {
+    methods: ['POST'],
+    authLevel: 'anonymous',
+    route: 'api/yeastar/{appInstallId}/call/journal',
+    handler: yeastarCallJournal
+});
+
+export async function yeastarCallJournal(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    let logger = childLogger({ requestId: context.invocationId, url: req.url });
+
+    logger.profile('http.inbound.yeastar.call.journal')
+
+    // const buildPath = path.join(__dirname, 'build');)
+
+    let seekaAppInstallId: string = req.params['appInstallId'];
+    logger = childLogger({ requestId: context.invocationId, url: req.url, seekaAppInstallId });
+
+    if (!seekaAppInstallId) {
+        logger.warn('Missing install ID');
+
+        return {
+            status: 404,
+            jsonBody: { error: "Missing install ID" }
+        }
+    }
+
+    await startServices(logger);
+
+    let installation = await tryGetInstallation(seekaAppInstallId as string, false, logger);
+    if (installation == null) {
+        logger.warn('Yeastar call cannot be processed as the installation ID is not known by this app');
+
+        return {
+            status: 422,
+            jsonBody: { error: "App not installed" }
+        }
+    }
+
+    try {
+        const body = cleanYeastarCallJournalPayload(await req.json());
+
+        await trackCallJournalLogInSeeka(body, installation, logger)
+
+        logger.verbose('Parsed yeastar call journal', { body });
+        return {
+            status: 200
+        }
+    }
+    catch (err) {
+        const winEx = winston.exceptions.getAllInfo(err)
+        logger.error('Failed to handle yeastar call journal', { ex: winEx, err: !winEx ? err?.toString() : undefined, url: req.url });
+        return {
+            status: 500,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: generateInboundWebhookResponseBody(false)
+        }
+    }
+    finally {
+        logger.profile('http.inbound.yeastar.call.journal')
+        logger.verbose('yeastar call journal handled');
+    }
+
+}
+
+const generateInboundWebhookResponseBody = (ack: boolean, message?: string) => {
+    return JSON.stringify({
+        success: ack,
+        message: message
+    }, null, 1)
+}

package/dist/ai-context/internal/examples/v2/yeastar/app/server/src/functions/yeastarContactCreate.ts

@@ -0,0 +1,86 @@
+import * as winston from 'winston';
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+import { childLogger } from '../lib/logging';
+
+
+app.http('yeastarContactCreate', {
+    methods: ['POST'],
+    authLevel: 'anonymous',
+    route: 'api/yeastar/{appInstallId}/contacts',
+    // route: 'api/yeastar/{appInstallId}/contacts/search?criteria=((Phone:equals:{{.Phone}})or(Home_Phone:equals:{{.Phone}})or(Mobile:equals:{{.Phone}})or(Asst_Phone:equals:{{.Phone}}))',
+    handler: yeastarContactCreate
+});
+
+export async function yeastarContactCreate(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 yeastar contacts create 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)
+    //     }
+    // }
+
+    logger.verbose('Received yeastar contacts create');
+    try {
+
+        logger.verbose('Received yeastar contacts create', { bodyStr: await req.text() });
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            //    body: JSON.stringify({
+            //     user_unique_id: "john.beale@jwbcomms.com.au",
+            //     first_name: 'John',
+            //     last_name: 'Beale',
+            //     email: 'john.beale@jwbcomms.com.au'
+            // })
+            body: JSON.stringify({
+                data: [
+                    {
+                        "name": "Bob12",
+                        "last_name": "Smith12",
+                        "phone": "0402928751",
+                        "mobile": "0402928751",
+                        "email": "bob@example122.com",
+                        "contact_id": "sk.1.123421312.12"
+                    }
+                ]
+            })
+        }
+    }
+    catch (err) {
+        const winEx = winston.exceptions.getAllInfo(err)
+        logger.error('Failed to handle yeastar contacts create', { 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.yeastar.user.get')
+        logger.verbose('yeastar contacts create handled');
+    }
+
+}
+
+const generateInboundWebhookResponseBody = (ack: boolean, message?: string) => {
+    return JSON.stringify({
+        success: ack,
+        message: message
+    }, null, 1)
+}

package/dist/ai-context/internal/examples/v2/yeastar/app/server/src/functions/yeastarContactPopup.ts

@@ -0,0 +1,84 @@
+import * as winston from 'winston';
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+import { childLogger } from '../lib/logging';
+
+
+app.http('yeastarContactPopup', {
+    methods: ['GET', 'POST'],
+    authLevel: 'anonymous',
+    route: 'api/yeastar/{appInstallId}/contacts/{contactId}/popup',
+    handler: yeastarContactPopup
+});
+
+export async function yeastarContactPopup(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    let logger = childLogger({ requestId: context.invocationId, url: req.url });
+
+
+    // 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 yeastar contacts search 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)
+    //     }
+    // }
+
+    logger.verbose('Received yeastar contacts popup');
+
+    try {
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            //    body: JSON.stringify({
+            //     user_unique_id: "john.beale@jwbcomms.com.au",
+            //     first_name: 'John',
+            //     last_name: 'Beale',
+            //     email: 'john.beale@jwbcomms.com.au'
+            // })
+            body: JSON.stringify({
+                data: [
+                    {
+                        "name": "Bob12",
+                        "last_name": "Smith12",
+                        "phone": "0402928751",
+                        "mobile": "0402928751",
+                        "email": "bob@example122.com",
+                        "contact_id": "sk.1.123421312.12"
+                    }
+                ]
+            })
+        }
+    }
+    catch (err) {
+        const winEx = winston.exceptions.getAllInfo(err)
+        logger.error('Failed to handle yeastar contacts popup', { ex: winEx, err: !winEx ? err?.toString() : undefined, url: req.url });
+        return {
+            status: 500,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: generateInboundWebhookResponseBody(false)
+        }
+    }
+    finally {
+        logger.profile('http.inbound.yeastar.contacts.popup')
+        logger.verbose('yeastar contacts popup handled');
+    }
+
+}
+
+const generateInboundWebhookResponseBody = (ack: boolean, message?: string) => {
+    return JSON.stringify({
+        success: ack,
+        message: message
+    }, null, 1)
+}

package/dist/ai-context/internal/examples/v2/yeastar/app/server/src/functions/yeastarContactsSearch.ts

@@ -0,0 +1,95 @@
+import * as winston from 'winston';
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+import { childLogger } from '../lib/logging';
+
+
+app.http('yeastarContactsSearch', {
+    methods: ['GET'],
+    authLevel: 'anonymous',
+    route: 'api/yeastar/{appInstallId}/contacts/search',
+    // route: 'api/yeastar/{appInstallId}/contacts/search?criteria=((Phone:equals:{{.Phone}})or(Home_Phone:equals:{{.Phone}})or(Mobile:equals:{{.Phone}})or(Asst_Phone:equals:{{.Phone}}))',
+    handler: yeastarContactsSearch
+});
+
+export async function yeastarContactsSearch(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    let logger = childLogger({ requestId: context.invocationId, url: req.url });
+
+    // 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 yeastar contacts search 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 {
+        logger.verbose('Received yeastar contacts search');
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            //    body: JSON.stringify({
+            //     user_unique_id: "john.beale@jwbcomms.com.au",
+            //     first_name: 'John',
+            //     last_name: 'Beale',
+            //     email: 'john.beale@jwbcomms.com.au'
+            // })
+            body: JSON.stringify({
+                data: [
+                    {
+                        "name": "",
+                        "last_name": "",
+                        "phone": req.query.get('phone'),
+                        "mobile": req.query.get('phone'),
+                        "email": "",
+                        "contact_id": "dummy"
+                    }
+                ]
+                // data: [
+                //     {
+                //         "name": "Bob",
+                //         "last_name": "Smith",
+                //         "phone": "0400000000",
+                //         "mobile": "0400000000",
+                //         "email": "bob@example.com",
+                //         "contact_id": "123",
+                //         "popup_url": "https://your-crm.com/contacts/123"
+                //     }
+                // ]
+            })
+        }
+    }
+    catch (err) {
+        const winEx = winston.exceptions.getAllInfo(err)
+        logger.error('Failed to handle yeastar contacts search', { ex: winEx, err: !winEx ? err?.toString() : undefined, url: req.url });
+        return {
+            status: 500,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: generateInboundWebhookResponseBody(false)
+        }
+    }
+    finally {
+        logger.profile('http.inbound.yeastar.user.get')
+        logger.verbose('yeastar contacts search handled');
+    }
+
+}
+
+const generateInboundWebhookResponseBody = (ack: boolean, message?: string) => {
+    return JSON.stringify({
+        success: ack,
+        message: message
+    }, null, 1)
+}

package/dist/ai-context/internal/examples/v2/yeastar/app/server/src/functions/yeastarGetUsers.ts

@@ -0,0 +1,120 @@
+import * as winston from 'winston';
+
+import { app, HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+import { childLogger } from '../lib/logging';
+import { startServices } from '../lib/services';
+import { tryGetInstallation } from '../lib/state/seeka/installations';
+
+
+app.http('yeastarGetUsers', {
+    methods: ['GET'],
+    authLevel: 'anonymous',
+    route: 'api/yeastar/{appInstallId}/users',
+    handler: yeastarGetUsers
+});
+
+export async function yeastarGetUsers(req: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
+    let logger = childLogger({ requestId: context.invocationId, url: req.url });
+
+    logger.profile('http.inbound.yeastar.user.get')
+
+    // const buildPath = path.join(__dirname, 'build');)
+
+    let seekaAppInstallId: string = req.params['appInstallId'];
+    logger = childLogger({ requestId: context.invocationId, url: req.url, seekaAppInstallId });
+
+    if (!seekaAppInstallId) {
+        logger.warn('Missing install ID');
+
+        return {
+            status: 404,
+            jsonBody: { error: "Missing install ID" }
+        }
+    }
+
+    await startServices(logger);
+
+    let installation = await tryGetInstallation(seekaAppInstallId as string, false, logger);
+    if (installation == null) {
+        logger.warn('Yeastar call cannot be processed as the installation ID is not known by this app');
+
+        return {
+            status: 422,
+            jsonBody: { error: "App not installed" }
+        }
+    }
+
+    // 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 yeastar get user 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 yeastar get user - 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 yeastar get users');
+        // const body = JSON.parse(bodyStr);
+
+
+        // let requestPayload = JSON.parse(bodyStr) as YeastarGetUserRequest;
+
+        return {
+            status: 200,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            //    body: JSON.stringify()
+            body: JSON.stringify({
+                data: installation.installationState?.yeastarUserMappings?.map(e => (
+                    { user_unique_id: e.email, first_name: e.firstName, last_name: e.lastName, email: e.email }
+                )) || []
+            })
+        }
+    }
+    catch (err) {
+        const winEx = winston.exceptions.getAllInfo(err)
+        logger.error('Failed to handle yeastar get users', { ex: winEx, err: !winEx ? err?.toString() : undefined, url: req.url });
+        return {
+            status: 500,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: generateInboundWebhookResponseBody(false)
+        }
+    }
+    finally {
+        logger.profile('http.inbound.yeastar.user.get')
+        logger.verbose('yeastar get users handled');
+    }
+
+}
+
+const generateInboundWebhookResponseBody = (ack: boolean, message?: string) => {
+    return JSON.stringify({
+        success: ack,
+        message: message
+    }, null, 1)
+}