@hubspot/ui-extensions-dev-server 1.1.8 → 2.0.0

package/dist/lib/__tests__/{app-functions/services/services_v20231.spec.js → serverless/services/services_v202603.spec.js}

@@ -1,13 +1,13 @@
 import { describe, it, expect, vi, afterEach, beforeEach, } from 'vitest';
 import httpMocks from 'node-mocks-http';
 import { EventEmitter } from 'node:events';
-import { AppFunctionExecutionService } from "../../../app-functions/services/index.js";
-import { TEST_CONFIG_V20231 as TEST_CONFIG } from "../fixtures/constants.js";
-import * as executor from "../../../app-functions/executor.js";
+import { AppFunctionExecutionService } from "../../../serverless/services/AppFunctionExecutionService.js";
+import { TEST_CONFIG_V202603 as TEST_CONFIG } from "../fixtures/constants.js";
+import * as executor from "../../../serverless/executor.js";
 import { scopesOnAccessToken as __scopesOnAccessToken } from '@hubspot/local-dev-lib/personalAccessKey';
-import { USER_TOKEN_READ, USER_TOKEN_WRITE, } from "../../../app-functions/services/constants.js";
-import { PrivateAppUserTokenManager } from "../../../app-functions/services/PrivateAppUserTokenManager.js";
-vi.mock('../../../app-functions/services/PrivateAppUserTokenManager.ts');
+import { USER_TOKEN_READ, USER_TOKEN_WRITE, } from "../../../serverless/services/constants.js";
+import { PrivateAppUserTokenManager } from "../../../serverless/services/PrivateAppUserTokenManager.js";
+vi.mock('../../../serverless/services/PrivateAppUserTokenManager.ts');
 vi.mock('@hubspot/local-dev-lib/personalAccessKey');
 const scopesOnAccessToken = __scopesOnAccessToken;
 const callAppFunction = async (functionName, parameters) => {
@@ -27,8 +27,6 @@ const callAppFunction = async (functionName, parameters) => {
         eventEmitter: EventEmitter,
     });
     const handler = AppFunctionExecutionService(TEST_CONFIG);
-    // Hold response until the handler finishes writing to it. THis must
-    // be set up before calling the handler or it may miss the `end` event.
     const responsePromised = new Promise((resolve) => {
         response.on('end', () => {
             resolve(response);
@@ -37,16 +35,12 @@ const callAppFunction = async (functionName, parameters) => {
     await handler(request, response);
     return await responsePromised;
 };
-/**
- * Validate the service for executing app functions
- */
-describe('app function dev server', () => {
+describe('app function dev server (v2026.03)', () => {
     const initialEnvJson = JSON.stringify(process.env);
     beforeEach(() => {
         scopesOnAccessToken.mockResolvedValue([USER_TOKEN_READ, USER_TOKEN_WRITE]);
     });
     afterEach(() => {
-        // restore process.env
         process.env = JSON.parse(initialEnvJson);
         vi.resetAllMocks();
         vi.restoreAllMocks();
@@ -54,184 +48,132 @@ describe('app function dev server', () => {
     it('returns "200 OK" response if function execution succeeded', async () => {
         const getTokenspy = vi.spyOn(PrivateAppUserTokenManager.prototype, 'getPrivateAppUserToken');
         const response = await callAppFunction('returns-text');
-        // Validate response status and body
         expect(response.statusCode).toEqual(200);
         expect(response._getJSONData()).toEqual({
             logId: 'n/a',
             response: 'result',
         });
-        // Validate log output
         expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "returns-text" execution succeeded'));
         expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
         expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
-        // Validate process.env is put back to what it was before the call
         expect(process.env).toEqual(JSON.parse(initialEnvJson));
-        // get the token
         expect(getTokenspy).toHaveBeenCalledTimes(1);
     });
     it('returns "400 Bad Request" response if function execution failed', async () => {
         const response = await callAppFunction('throws-error');
-        // Validate response status and body
         expect(response.statusCode).toEqual(400);
         const body = response._getJSONData();
         expect(body).toHaveProperty('status', 'error');
         expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
         const exception = body.errors?.[0]?.context?.exception?.[0];
         expect(exception).toEqual('Error: Oops');
-        // Validate log output
         expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "throws-error" execution failed'));
         expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function encountered an uncaught error.', expect.anything());
-        // Validate process.env is put back to what it was before the call
         expect(process.env).toEqual(JSON.parse(initialEnvJson));
     });
     describe('handles asynchronous functions (promise chaining)', () => {
         it('returns "200 OK" response if function returns a promise that resolves', async () => {
             const response = await callAppFunction('returns-promise-resolved');
-            // Validate response status and body
             expect(response.statusCode).toEqual(200);
             expect(response._getJSONData()).toEqual({
                 logId: 'n/a',
                 response: { result: 'simulated' },
             });
-            // Validate log output
             expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "returns-promise-resolved" execution succeeded'));
             expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
             expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
-            // Validate process.env is put back to what it was before the call
             expect(process.env).toEqual(JSON.parse(initialEnvJson));
         });
         it('returns "400 Bad Request" response if function returns a promise that rejects', async () => {
             const response = await callAppFunction('returns-promise-rejected');
-            // Validate response status and body
             expect(response.statusCode).toEqual(400);
             const body = response._getJSONData();
             expect(body).toHaveProperty('status', 'error');
             expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
             const exception = body.errors?.[0]?.context?.exception?.[0];
             expect(exception).toEqual('Error: fail');
-            // Validate log output
             expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "returns-promise-rejected" execution failed'));
             expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function encountered an uncaught error.', expect.anything());
-            // Validate process.env is put back to what it was before the call
             expect(process.env).toEqual(JSON.parse(initialEnvJson));
         });
     });
     describe('handles asynchronous functions (async/await)', () => {
         it('returns "200 OK" response if an async function execution succeeded', async () => {
             const response = await callAppFunction('async-succeeds');
-            // Validate response status and body
             expect(response.statusCode).toEqual(200);
             expect(response._getJSONData()).toEqual({
                 logId: 'n/a',
                 response: { result: 'simulated' },
             });
-            // Validate log output
             expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "async-succeeds" execution succeeded'));
             expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
             expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
-            // Validate process.env is put back to what it was before the call
             expect(process.env).toEqual(JSON.parse(initialEnvJson));
         });
         it('returns "400 Bad Request" response if an async function execution failed', async () => {
             const response = await callAppFunction('async-fails');
-            // Validate response status and body
             expect(response.statusCode).toEqual(400);
             const body = response._getJSONData();
             expect(body).toHaveProperty('status', 'error');
             expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
             const exception = body.errors?.[0]?.context?.exception?.[0];
             expect(exception).toEqual('Error: fail');
-            // Validate log output
             expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "async-fails" execution failed'));
             expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function encountered an uncaught error.', expect.anything());
-            // Validate process.env is put back to what it was before the call
             expect(process.env).toEqual(JSON.parse(initialEnvJson));
         });
     });
-    describe('handles functions with floating promises (only 2023.1)', () => {
-        it('returns "200 OK" response if function makes a promise that resolves and calls callback', async () => {
-            const response = await callAppFunction('callback-on-promise-resolved');
-            // Validate response status and body
-            expect(response.statusCode).toEqual(200);
-            expect(response._getJSONData()).toEqual({
-                logId: 'n/a',
-                response: { result: 'simulated' },
-            });
-            // Validate log output
-            expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "callback-on-promise-resolved" execution succeeded'));
-            expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
-            expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
-            // Validate process.env is put back to what it was before the call
-            expect(process.env).toEqual(JSON.parse(initialEnvJson));
-        });
-        it('returns "200 OK" response if function makes a promise that rejects and calls callback', async () => {
-            const response = await callAppFunction('callback-on-promise-rejected');
-            // Validate response status and body
-            expect(response.statusCode).toEqual(200);
-            expect(response._getJSONData()).toEqual({
-                logId: 'n/a',
-                response: { error: 'Error: fail' },
-            });
-            // Validate log output
-            expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "callback-on-promise-rejected" execution succeeded'));
-            expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
-            expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
-            // Validate process.env is put back to what it was before the call
-            expect(process.env).toEqual(JSON.parse(initialEnvJson));
+    it('returns "200 OK" response if function returns implicitly', async () => {
+        const response = await callAppFunction('returns-implicitly');
+        expect(response.statusCode).toEqual(200);
+        expect(response._getJSONData()).toEqual({
+            logId: 'n/a',
+            response: null,
         });
+        expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "returns-implicitly" execution succeeded'));
+        expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
+        expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
+        expect(process.env).toEqual(JSON.parse(initialEnvJson));
     });
     it('returns "400 Bad Request" response if function not found', async () => {
         const response = await callAppFunction('does-not-exist');
-        // Validate response status and body
         expect(response.statusCode).toEqual(400);
         const body = response._getJSONData();
         expect(body).toHaveProperty('status', 'error');
         expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
         const exception = body.errors?.[0]?.context?.exception?.[0];
         expect(exception).toMatch(/doesn't exist in this project/);
-        // Validate log output
         expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "does-not-exist" execution failed'));
         expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith(expect.stringContaining('Could not find file'));
-        // Validate process.env is put back to what it was before the call
         expect(process.env).toEqual(JSON.parse(initialEnvJson));
     });
     it('returns "400 Bad Request" response if function does not export main', async () => {
-        // TEST_CONFIG.functionTimeoutMs = 250
         const response = await callAppFunction('does-not-export-main');
-        // Validate response status and body
         expect(response.statusCode).toEqual(400);
         const body = response._getJSONData();
         expect(body).toHaveProperty('status', 'error');
         expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
         const exception = body.errors?.[0]?.context?.exception?.[0];
         expect(exception).toMatch(/customerPayload\.main is not a function/);
-        // Validate log output
         expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "does-not-export-main" execution failed'));
         expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith(expect.stringContaining('Could not find "main" export in'));
-        // Validate process.env is put back to what it was before the call
         expect(process.env).toEqual(JSON.parse(initialEnvJson));
     });
     it('returns "400 Bad Request" response if function returns invalid json', async () => {
-        // TEST_CONFIG.functionTimeoutMs = 250
         const response = await callAppFunction('returns-function');
-        // Validate response status and body
         expect(response.statusCode).toEqual(400);
         const body = response._getJSONData();
         expect(body).toHaveProperty('status', 'error');
         expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
         const exception = body.errors?.[0]?.context?.exception?.[0];
         expect(exception).toMatch(/Wrong arguments/);
-        // Validate log output
         expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "returns-function" execution failed'));
         expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function reponse is not valid JSON.');
-        // Validate process.env is put back to what it was before the call
         expect(process.env).toEqual(JSON.parse(initialEnvJson));
     });
     it('returns "200 OK" response if function returns before timeout', async () => {
-        // TEST_CONFIG.functionTimeoutMs = 250
         const response = await callAppFunction('times-out', { delayMs: 200 });
-        const variance = 5; // milliseconds
-        // Validate response status and body
+        const variance = 10;
         expect(response.statusCode).toEqual(200);
         const body = response._getJSONData();
         expect(body).toEqual({
@@ -240,27 +182,21 @@ describe('app function dev server', () => {
         });
         expect(body.response.elapsedMs).toBeGreaterThanOrEqual(200 - variance);
         expect(body.response.elapsedMs).toBeLessThanOrEqual(200 + variance);
-        // Validate log output
         expect(TEST_CONFIG.logger.debug).toHaveBeenCalledWith(expect.stringContaining('App function "times-out" execution succeeded'));
         expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
         expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
-        // Validate process.env is put back to what it was before the call
         expect(process.env).toEqual(JSON.parse(initialEnvJson));
     });
     it('returns "400 Bad Request" response if function returns after timeout', async () => {
-        // TEST_CONFIG.functionTimeoutMs = 250
         const response = await callAppFunction('times-out', { delayMs: 300 });
-        // Validate response status and body
         expect(response.statusCode).toEqual(400);
         const body = response._getJSONData();
         expect(body).toHaveProperty('status', 'error');
         expect(body).toHaveProperty('category', 'VALIDATION_ERROR');
         const exception = body.errors?.[0]?.context?.exception?.[0];
         expect(exception).toMatch(/Task timed out after/);
-        // Validate log output
         expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "times-out" execution failed'));
         expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith('App function failed to callback within 0.25 second.');
-        // Validate process.env is put back to what it was before the call
         expect(process.env).toEqual(JSON.parse(initialEnvJson));
     });
     it('returns "500 Internal Server Error" response if something went wrong', async () => {
@@ -268,18 +204,14 @@ describe('app function dev server', () => {
         vi.spyOn(executor, 'executeFunction').mockImplementation(() => {
             throw error;
         });
-        // Act
         const response = await callAppFunction('returns-text');
-        // Validate response status and body
         expect(response.statusCode).toEqual(500);
         const body = response._getJSONData();
         expect(body).toHaveProperty('status', 'error');
         expect(body).not.toHaveProperty('category', 'INTERNAL_ERROR');
         expect(body).toHaveProperty('message', 'internal error');
-        // Validate log output
         expect(TEST_CONFIG.logger.warn).toHaveBeenCalledWith(expect.stringContaining('App function "returns-text" execution failed due to server internal error'));
         expect(TEST_CONFIG.logger.error).toHaveBeenCalledWith(error);
-        // Validate process.env is put back to what it was before the call
         expect(process.env).toEqual(JSON.parse(initialEnvJson));
     });
     it('logs to console from inside the function', async () => {
@@ -288,15 +220,12 @@ describe('app function dev server', () => {
         const info = vi.spyOn(console, 'info').mockImplementation(() => { });
         const warn = vi.spyOn(console, 'warn').mockImplementation(() => { });
         const error = vi.spyOn(console, 'error').mockImplementation(() => { });
-        // Act
         const response = await callAppFunction('logs');
-        // Validate response status and body
         expect(response.statusCode).toEqual(200);
         expect(response._getJSONData()).toEqual({
             logId: 'n/a',
             response: { status: 'success' },
         });
-        // Validate function logging
         expect(log).toHaveBeenCalledTimes(1);
         expect(log).toHaveBeenCalledWith('log line');
         expect(debug).toHaveBeenCalledTimes(1);
@@ -308,12 +237,10 @@ describe('app function dev server', () => {
         expect(warn).toHaveBeenCalledWith('warn line');
         expect(error).toHaveBeenCalledTimes(1);
         expect(error).toHaveBeenCalledWith('error line');
-        // Validate service logging, which is separate from function logging
         expect(TEST_CONFIG.logger.debug).toHaveBeenCalledTimes(1);
         expect(TEST_CONFIG.logger.debug).toHaveBeenNthCalledWith(1, expect.stringContaining('App function "logs" execution succeeded'));
         expect(TEST_CONFIG.logger.warn).toHaveBeenCalledTimes(0);
         expect(TEST_CONFIG.logger.error).toHaveBeenCalledTimes(0);
-        // Validate process.env is put back to what it was before the call
         expect(process.env).toEqual(JSON.parse(initialEnvJson));
     });
 });

package/dist/lib/__tests__/serverless/setup.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/__tests__/utils.spec.js

@@ -1,8 +1,9 @@
 import { describe, it, expect, vi, beforeAll, afterAll, beforeEach, afterEach, } from 'vitest';
 import { OUTPUT_DIR } from "../constants.js";
-import { getUrlSafeFileName, stripAnsiColorCodes, loadManifest, buildSourceId, isNodeModule, isExtensionFile, generateHash, } from "../utils.js";
+import { getUrlSafeFileName, stripAnsiColorCodes, loadManifest, buildSourceId, isNodeModule, isExtensionFile, generateHash, isUnifiedAppConfig, } from "../utils.js";
 import fs from 'fs';
 import path from 'path';
+import { UnifiedAppAuthTypes, } from "../types.js";
 describe('utils', () => {
     describe('getUrlSafeFileName', () => {
         it('should uri encode the filename', () => {
@@ -128,6 +129,30 @@ describe('utils', () => {
             process.chdir(originalCwd);
         });
     });
+    describe('isUnifiedAppConfig', () => {
+        it('should return true for a unified app config', () => {
+            const config = {
+                unified: true,
+                name: 'Test',
+                uid: 'test-uid',
+                auth: { type: UnifiedAppAuthTypes.OAUTH },
+                distribution: 'private',
+                isPublicApp: true,
+                extensions: { crm: { cards: [] } },
+            };
+            expect(isUnifiedAppConfig(config)).toBe(true);
+        });
+        it('should return false for a legacy app config', () => {
+            const config = {
+                name: 'Test',
+                uid: 'test-uid',
+                scopes: [],
+                public: false,
+                extensions: { crm: { cards: [] } },
+            };
+            expect(isUnifiedAppConfig(config)).toBe(false);
+        });
+    });
     describe('generateHash', () => {
         it('should generate consistent hashes for same inputs', () => {
             const hash1 = generateHash('test', ['a', 'b'], { foo: 'bar' });

package/dist/lib/constants.d.ts

@@ -17,10 +17,10 @@ export declare const WEBSOCKET_MESSAGE_VERSION = 1;
 export declare const PROXY_CAPABILITY = "app-backend-proxy-server";
 export declare const SERVER_CAPABILITIES: string[];
 export declare const PLATFORM_VERSION: {
-    readonly V20231: "2023.1";
-    readonly V20232: "2023.2";
     readonly V20251: "2025.1";
     readonly V20252: "2025.2";
+    readonly V202603: "2026.03";
+    readonly V202603BETA: "2026.03-beta";
     readonly UNSTABLE: "unstable";
 };
 export declare const PUBLIC_APP = "public-app";

package/dist/lib/constants.js

@@ -24,10 +24,10 @@ export const SERVER_CAPABILITIES = [
     'account-id',
 ];
 export const PLATFORM_VERSION = {
-    V20231: '2023.1',
-    V20232: '2023.2',
     V20251: '2025.1',
     V20252: '2025.2',
+    V202603: '2026.03',
+    V202603BETA: '2026.03-beta',
     UNSTABLE: 'unstable',
 };
 export const PUBLIC_APP = 'public-app';

package/dist/lib/{app-functions/errorReporter.js → errorReporter.js}

@@ -1,12 +1,12 @@
 import * as Sentry from '@sentry/node';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-const version = JSON.parse(readFileSync(join(import.meta.dirname, '../../../package.json'), 'utf-8')).version;
+const version = JSON.parse(readFileSync(join(import.meta.dirname, '../../package.json'), 'utf-8')).version;
 const DSN_KEY = 'fbfd0619a2c1af3be058700da25fe9f1';
 const LOGFETCH_DSN = `https://${DSN_KEY}@exceptions.hubspot.com/v2/1`;
 Sentry.init({
     dsn: LOGFETCH_DSN,
-    release: `@hubspot/app-functions-dev-server@${version}`,
+    release: `@hubspot/ui-extensions-dev-server@${version}`,
     initialScope: {
         tags: {
             devServerVersion: version,

package/dist/lib/extensionsService.js

@@ -30,6 +30,12 @@ class ExtensionsService {
                     ...(devServerState.functionsConfig.platformVersion && {
                         platformVersion: devServerState.functionsConfig.platformVersion,
                     }),
+                    ...(devServerState.authType && {
+                        authType: devServerState.authType,
+                    }),
+                    ...(devServerState.distribution && {
+                        distribution: devServerState.distribution,
+                    }),
                 };
                 res.status(200).json(response);
             }

package/dist/lib/{app-functions/services → proxy}/AppProxyService.d.ts

@@ -1,5 +1,5 @@
 import { AxiosError } from 'axios';
-import { LocalDevUrlMapping, ProxyServiceConfig, ProxyServerError } from '../types.ts';
+import { LocalDevUrlMapping, ProxyServiceConfig, ProxyServerError } from './types.ts';
 export declare const mapToLocalUrl: (localDevUrlMapping: LocalDevUrlMapping, requestUri: string, allowedUrls: string[], logger: ProxyServiceConfig["logger"]) => string;
 export declare const extractErrorData: (e: unknown | AxiosError) => ProxyServerError;
 export declare const AppProxyService: ({ localDevUrlMapping, logger, accountId, allowedUrls, }: ProxyServiceConfig) => import("express-serve-static-core").Express;

package/dist/lib/{app-functions/services → proxy}/AppProxyService.js

@@ -2,8 +2,8 @@ import express from 'express';
 import cors from 'cors';
 import axios, { isAxiosError } from 'axios';
 import crypto from 'node:crypto';
-import { axiosErrorMappings, defaultServerError, localProxyErrorMappings, } from "../constants.js";
-import { getSignatureHeaders } from "../signing.js";
+import { axiosErrorMappings, defaultServerError, localProxyErrorMappings, } from "./constants.js";
+import { getSignatureHeaders } from "./signing.js";
 import { reportError } from "../errorReporter.js";
 export const mapToLocalUrl = (localDevUrlMapping, requestUri, allowedUrls, logger) => {
     const url = new URL(requestUri);
@@ -21,7 +21,7 @@ export const mapToLocalUrl = (localDevUrlMapping, requestUri, allowedUrls, logge
     if (parsedLocalMapping.pathname !== '/') {
         // If the local pathname ends with '/', remove it to avoid '//' in the path
         const localPathname = parsedLocalMapping.pathname.endsWith('/')
-            ? parsedLocalMapping.pathname.slice(0, 1)
+            ? parsedLocalMapping.pathname.slice(0, -1)
             : parsedLocalMapping.pathname;
         url.pathname = `${localPathname}${url.pathname}`;
     }
@@ -55,6 +55,7 @@ export const AppProxyService = ({ localDevUrlMapping, logger, accountId, allowed
         const { requestUri, method, requestTimeoutMillis, requestBody, requestHeaders, } = 
         /* eslint-disable-next-line no-unsafe-optional-chaining */
         req?.body;
+        let requestFailed = false;
         try {
             logger.info(`Request to ${requestUri} started, method=${method}, correlationId=${correlationId}`);
             const url = mapToLocalUrl(localDevUrlMapping, requestUri, allowedUrls, logger);
@@ -139,7 +140,17 @@ export const AppProxyService = ({ localDevUrlMapping, logger, accountId, allowed
             });
         }
         catch (e) {
+            requestFailed = true;
             const { status, message, category, data: responseBody, } = extractErrorData(e);
+            // If it's an Axios error with a response, it's a server error from the app server and we simply warn about it.
+            if (isAxiosError(e) && e.response) {
+                logger.warn(`Request to ${requestUri} returned HTTP ${status}, correlationId=${correlationId}`);
+            }
+            else {
+                // Other failures are likely related to the local proxy itself, such as network errors, CORS issues, or misconfiguration. We log these as errors for visibility.
+                const errorMessage = e instanceof Error ? e.message : 'Unknown error';
+                logger.error(`Request to ${requestUri} failed: ${errorMessage}, correlationId=${correlationId}`);
+            }
             // Report non-Axios errors (dev server bugs)
             if (!isAxiosError(e)) {
                 reportError(e, {
@@ -189,7 +200,7 @@ export const AppProxyService = ({ localDevUrlMapping, logger, accountId, allowed
             });
         }
         finally {
-            logger.info(`Request completed, correlationId=${correlationId}`);
+            logger.info(`Request ${requestFailed ? 'failed' : 'completed'}, correlationId=${correlationId}`);
         }
     });
     return app;

package/dist/lib/proxy/constants.d.ts

@@ -0,0 +1,13 @@
+import { ProxyServerError } from './types.ts';
+export declare const defaultServerError: ProxyServerError;
+export declare const validationError: Omit<ProxyServerError, 'message' | 'data'>;
+export declare const axiosErrorMappings: {
+    [key: string]: ProxyServerError;
+};
+export declare const localProxyErrorMappings: {
+    BAD_GATEWAY: {
+        status: number;
+        category: string;
+        message: string;
+    };
+};

package/dist/lib/{app-functions → proxy}/constants.js

@@ -1,22 +1,4 @@
 import { AxiosError, HttpStatusCode } from 'axios';
-export const APP_FUNCTIONS_DIRNAME = 'app.functions';
-export const APP_FUNCTIONS_MANIFEST_FILENAME = 'serverless.json';
-export const DEV_SERVER_DEFAULT_PORT = 6789;
-export const EXECUTION_TIMEOUT_MS = 15_000;
-export const PRIVATE_APP_ACCESS_TOKEN = 'PRIVATE_APP_ACCESS_TOKEN';
-export const SECRETS_IN_CONTEXT = [
-    PRIVATE_APP_ACCESS_TOKEN,
-    'HS_ENVIRONMENT',
-    'HS_HUBLET',
-    'HS_SERVERLESS_FUNCTION_ID',
-];
-export const PLATFORM_VERSION = {
-    V20231: '2023.1',
-    V20232: '2023.2',
-    V20251: '2025.1',
-    V20252: '2025.2',
-    UNSTABLE: 'unstable',
-};
 export const defaultServerError = {
     status: HttpStatusCode.InternalServerError,
     message: 'Failure observed in UI Extensions Proxy Server. Contact Hubspot Support if the problem persists',

package/dist/lib/proxy/types.d.ts

@@ -0,0 +1,44 @@
+export interface LocalDevUrlMapping {
+    [hostUrl: string]: string;
+}
+export interface ProxyServiceConfig {
+    logger: Pick<typeof console, 'debug' | 'info' | 'warn' | 'error'>;
+    localDevUrlMapping: LocalDevUrlMapping;
+    accountId: number;
+    allowedUrls: string[];
+}
+interface Context {
+    correlationId: string[];
+    httpMethod: string[];
+    appServerStatusCode?: string[];
+    portalId: string[];
+    requestUri: string[];
+}
+export interface AppProxyServiceSuccessResponse {
+    status: 'success';
+    responseBody: unknown;
+    context: Context;
+}
+export interface AppProxyServiceErrorResponse {
+    status: 'error';
+    category: string;
+    message: string;
+    context: Context;
+    errors?: unknown[];
+    responseBody?: unknown;
+}
+export type AppProxyServiceResponse = AppProxyServiceSuccessResponse | AppProxyServiceErrorResponse;
+export interface ProxyServerError {
+    status: number;
+    data?: unknown;
+    message: string;
+    category: string;
+}
+export interface ProxyRequest {
+    requestUri: string;
+    method: string;
+    requestTimeoutMillis: number;
+    requestBody: unknown;
+    requestHeaders?: Record<string, string>;
+}
+export {};

package/dist/lib/proxy/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/server.js

@@ -2,7 +2,8 @@ import express from 'express';
 import cors from 'cors';
 import { PROXY_CAPABILITY, SERVER_CAPABILITIES, WEBSOCKET_MESSAGE_VERSION, } from "./constants.js";
 import extensionsService from "./extensionsService.js";
-import { AppFunctionExecutionService, AppProxyService, } from "./app-functions/services/index.js";
+import { AppFunctionExecutionService } from "./serverless/services/AppFunctionExecutionService.js";
+import { AppProxyService } from "./proxy/AppProxyService.js";
 import { extractAllowedUrls } from "./utils.js";
 import { ExtensionsWebSocket } from "./ExtensionsWebSocket.js";
 function listen(app, port) {