@alwaysai/device-agent 2.1.2 → 2.1.3

package/src/application-control/environment-variables.test.ts

@@ -2,8 +2,9 @@ import { AgentConfigFile } from '../infrastructure/agent-config';
 import { readDockerCompose, writeDockerCompose } from './config';
 import {
   convertStringEnvsToKeyVal,
-  getAllEnvs,
-  setEnv
+  getAllEnvVars,
+  setEnvVars,
+  updateEnvVarsInternal
 } from './environment-variables';
 import { isAppStarted, restartApp } from './status';
 import { buildApp, requireAppReady } from './utils';
@@ -33,7 +34,7 @@ describe('Test environment variable get and set', () => {
   beforeEach(() => {
     jest.clearAllMocks();
   });
-  describe('Test getAllEnvs()', () => {
+  describe('Test getAllEnvVars()', () => {
     test('get all envs with one service and no envs', async () => {
       const compose = {
         services: {
@@ -42,7 +43,7 @@ describe('Test environment variable get and set', () => {
       };
       jest.mocked(readDockerCompose).mockResolvedValue(compose);
 
-      const envVars = await getAllEnvs({ projectId: projectId1 });
+      const envVars = await getAllEnvVars({ projectId: projectId1 });
       expect(jest.mocked(readDockerCompose)).toBeCalledWith({
         projectId: projectId1
       });
@@ -61,7 +62,7 @@ describe('Test environment variable get and set', () => {
       };
       jest.mocked(readDockerCompose).mockResolvedValue(compose);
 
-      const envVars = await getAllEnvs({ projectId: projectId1 });
+      const envVars = await getAllEnvVars({ projectId: projectId1 });
       expect(jest.mocked(readDockerCompose)).toBeCalledWith({
         projectId: projectId1
       });
@@ -82,7 +83,7 @@ describe('Test environment variable get and set', () => {
       };
       jest.mocked(readDockerCompose).mockResolvedValue(compose);
 
-      const envVars = await getAllEnvs({ projectId: projectId1 });
+      const envVars = await getAllEnvVars({ projectId: projectId1 });
       expect(jest.mocked(readDockerCompose)).toBeCalledWith({
         projectId: projectId1
       });
@@ -101,7 +102,7 @@ describe('Test environment variable get and set', () => {
       };
       jest.mocked(readDockerCompose).mockResolvedValue(compose);
 
-      const envVars = await getAllEnvs({ projectId: projectId1 });
+      const envVars = await getAllEnvVars({ projectId: projectId1 });
       expect(jest.mocked(readDockerCompose)).toBeCalledWith({
         projectId: projectId1
       });
@@ -110,7 +111,7 @@ describe('Test environment variable get and set', () => {
       });
     });
   });
-  describe('Test setEnv()', () => {
+  describe('Test setEnvVars()', () => {
     test('Set one env', async () => {
       const compose = {
         services: {
@@ -120,7 +121,7 @@ describe('Test environment variable get and set', () => {
       jest.mocked(readDockerCompose).mockResolvedValue(compose);
 
       const envVars = { alwaysai: { TEST: '1' } };
-      await setEnv({ projectId: projectId1, envVars });
+      await setEnvVars({ projectId: projectId1, envVars });
       expect(jest.mocked(readDockerCompose)).toBeCalledWith({
         projectId: projectId1
       });
@@ -145,7 +146,7 @@ describe('Test environment variable get and set', () => {
       jest.mocked(readDockerCompose).mockResolvedValue(compose);
 
       const envVars = { alwaysai: { TEST1: '2', TEST2: '2' } };
-      await setEnv({ projectId: projectId1, envVars });
+      await setEnvVars({ projectId: projectId1, envVars });
       expect(jest.mocked(readDockerCompose)).toBeCalledWith({
         projectId: projectId1
       });
@@ -174,7 +175,7 @@ describe('Test environment variable get and set', () => {
         alwaysai: { TEST1: '2', TEST2: '4' },
         other: { OTHER_TEST: '1' }
       };
-      await setEnv({ projectId: projectId1, envVars });
+      await setEnvVars({ projectId: projectId1, envVars });
       expect(jest.mocked(readDockerCompose)).toBeCalledWith({
         projectId: projectId1
       });
@@ -202,7 +203,7 @@ describe('Test environment variable get and set', () => {
       jest.mocked(readDockerCompose).mockResolvedValue(compose);
 
       const envVars = { alwaysai: { TEST1: '', TEST2: '2' } };
-      await setEnv({ projectId: projectId1, envVars });
+      await setEnvVars({ projectId: projectId1, envVars });
       expect(jest.mocked(readDockerCompose)).toBeCalledWith({
         projectId: projectId1
       });
@@ -229,4 +230,159 @@ describe('Test environment variable get and set', () => {
       });
     });
   });
+  describe('Test updateEnvVarsInternal()', () => {
+    test('add env var to project before docker-compose.yaml is written', async () => {
+      jest.mocked(readDockerCompose).mockResolvedValue({});
+      const newEnvVars = {
+        alwaysai: {
+          TEST: '1'
+        }
+      };
+
+      await expect(
+        updateEnvVarsInternal({
+          projectId: projectId1,
+          envVars: newEnvVars
+        })
+      ).rejects.toThrow(
+        `Docker compose file for ${projectId1} has no services!`
+      );
+    });
+    test('add env var to empty environment variables', async () => {
+      const compose = {
+        services: {
+          alwaysai: {}
+        }
+      };
+      jest.mocked(readDockerCompose).mockResolvedValue(compose);
+      const newEnvVars = {
+        alwaysai: {
+          TEST: '1'
+        }
+      };
+
+      await updateEnvVarsInternal({
+        projectId: projectId1,
+        envVars: newEnvVars
+      });
+      expect(jest.mocked(readDockerCompose)).toBeCalledWith({
+        projectId: projectId1
+      });
+      expect(jest.mocked(writeDockerCompose)).toBeCalledWith({
+        projectId: projectId1,
+        dockerCompose: {
+          services: {
+            alwaysai: {
+              environment: ['TEST=1']
+            }
+          }
+        }
+      });
+    });
+    test('add env var to existing environment variables', async () => {
+      const compose = {
+        services: {
+          alwaysai: {
+            environment: ['TEST2=2']
+          }
+        }
+      };
+      jest.mocked(readDockerCompose).mockResolvedValue(compose);
+      const newEnvVars = {
+        alwaysai: {
+          TEST: '1'
+        }
+      };
+
+      await updateEnvVarsInternal({
+        projectId: projectId1,
+        envVars: newEnvVars
+      });
+      expect(jest.mocked(readDockerCompose)).toBeCalledWith({
+        projectId: projectId1
+      });
+      expect(jest.mocked(writeDockerCompose)).toBeCalledWith({
+        projectId: projectId1,
+        dockerCompose: {
+          services: {
+            alwaysai: {
+              environment: ['TEST2=2', 'TEST=1']
+            }
+          }
+        }
+      });
+    });
+    test('add env var to alwaysai service when multiple exist', async () => {
+      const compose = {
+        services: {
+          test: {
+            environment: ['TEST1=1', 'TEST2=2']
+          },
+          alwaysai: {
+            environment: ['TEST2=2']
+          }
+        }
+      };
+      jest.mocked(readDockerCompose).mockResolvedValue(compose);
+      const newEnvVars = {
+        alwaysai: {
+          TEST: '1'
+        }
+      };
+
+      await updateEnvVarsInternal({
+        projectId: projectId1,
+        envVars: newEnvVars
+      });
+      expect(jest.mocked(readDockerCompose)).toBeCalledWith({
+        projectId: projectId1
+      });
+      expect(jest.mocked(writeDockerCompose)).toBeCalledWith({
+        projectId: projectId1,
+        dockerCompose: {
+          services: {
+            test: {
+              environment: ['TEST1=1', 'TEST2=2']
+            },
+            alwaysai: {
+              environment: ['TEST2=2', 'TEST=1']
+            }
+          }
+        }
+      });
+    });
+    test('add env var when it already exists for the service', async () => {
+      const compose = {
+        services: {
+          alwaysai: {
+            environment: ['TEST=1']
+          }
+        }
+      };
+      jest.mocked(readDockerCompose).mockResolvedValue(compose);
+      const newEnvVars = {
+        alwaysai: {
+          TEST: '1'
+        }
+      };
+
+      await updateEnvVarsInternal({
+        projectId: projectId1,
+        envVars: newEnvVars
+      });
+      expect(jest.mocked(readDockerCompose)).toBeCalledWith({
+        projectId: projectId1
+      });
+      expect(jest.mocked(writeDockerCompose)).toBeCalledWith({
+        projectId: projectId1,
+        dockerCompose: {
+          services: {
+            alwaysai: {
+              environment: ['TEST=1']
+            }
+          }
+        }
+      });
+    });
+  });
 });

package/src/application-control/environment-variables.ts

@@ -1,12 +1,21 @@
+import { EnvVars } from '@alwaysai/device-agent-schemas';
 import { JsSpawner } from 'alwaysai/lib/util';
-import { readDockerCompose, writeDockerCompose } from './config';
-import { buildApp, getAppDir, requireAppReady } from './utils';
-import { logger } from '../util/logger';
 import { AgentConfigFile } from '../infrastructure/agent-config';
+import { logger } from '../util/logger';
+import { readDockerCompose, writeDockerCompose } from './config';
 import { isAppStarted, restartApp } from './status';
-import { EnvVars } from '@alwaysai/device-agent-schemas';
+import { buildApp, getAppDir, requireAppReady } from './utils';
 
-export async function setEnv(props: {
+/**
+ * Overrides the current environment variables specified in the
+ * docker-compose.yaml file.
+ *
+ * @param props.projectId - The project ID.
+ * @param props.envVars - The environment variables to override the
+ * ones currently in docker-compose.yaml
+ * @raises When called if there are no services in a docker-compose.yaml file
+ */
+export async function setEnvVars(props: {
   projectId: string;
   envVars: EnvVars;
 }): Promise<void> {
@@ -18,7 +27,7 @@ export async function setEnv(props: {
     projectId,
     version: appReleaseHash
   });
-  await setEnvInternal({ projectId, envVars });
+  await setEnvVarsInternal({ projectId, envVars });
 
   const appDir = getAppDir(projectId);
   await buildApp({ appDir });
@@ -40,7 +49,18 @@ export async function setEnv(props: {
   );
 }
 
-export async function setEnvInternal(props: {
+/**
+ * Overrides the current environment variables specified in the
+ * docker-compose.yaml file. Intended for internal use only, as
+ * it does not check if there is an installation in progress
+ * before proceeding with the environment variable update.
+ *
+ * @param props.projectId - The project ID.
+ * @param props.envVars - The environment variables to override the
+ * ones currently in docker-compose.yaml
+ * @raises When called if there are no services in a docker-compose.yaml file
+ */
+export async function setEnvVarsInternal(props: {
   projectId: string;
   envVars: EnvVars;
 }): Promise<void> {
@@ -76,7 +96,15 @@ export async function setEnvInternal(props: {
   await writeDockerCompose({ projectId, dockerCompose: composeParsed });
 }
 
-export function convertStringEnvsToKeyVal(stringEnvs: string[]) {
+/**
+ * Converts a string array of environment variables into an iterable object,
+ * where each string is converted to a key-value pair.
+ *
+ * @param stringEnvs - Environment variables in the format of
+ * ['<variableName>=<variableValue>', '<variableName>=<variableValue>']
+ * @returns The variables as an object, as key-value pairs
+ */
+export function convertStringEnvsToKeyVal(stringEnvs: string[]): any {
   const envVars = {};
   stringEnvs.forEach((env: string) => {
     const keyVal = env.split('=');
@@ -85,11 +113,34 @@ export function convertStringEnvsToKeyVal(stringEnvs: string[]) {
   return envVars;
 }
 
-export async function getAllEnvs(props: {
+/**
+ * Returns all environment variables for all services currently set
+ * in the docker-compose.yaml file.
+ *
+ * @param props.projectId -  The project ID
+ * @raises When called if there are no services in a docker-compose.yaml file
+ */
+export async function getAllEnvVars(props: {
   projectId: string;
 }): Promise<EnvVars> {
   const { projectId } = props;
   await requireAppReady({ projectId });
+  return getAllEnvVarsInternal(props);
+}
+
+/**
+ * Returns all environment variables for all services currently set
+ * in the docker-compose.yaml file. Intended for internal use only, as
+ * it does not check if there is an installation in progress
+ * before proceeding with the environment variable lookup.
+ *
+ * @param props.projectId -  The project ID
+ * @raises When called if there are no services in a docker-compose.yaml file
+ */
+export async function getAllEnvVarsInternal(props: {
+  projectId: string;
+}): Promise<EnvVars> {
+  const { projectId } = props;
   const appDir = getAppDir(projectId);
   const spawner = JsSpawner({ path: appDir });
   const envVars: EnvVars = {};
@@ -127,3 +178,34 @@ export async function getAllEnvs(props: {
   }
   return envVars;
 }
+
+/**
+ * Adds new environment variables to the existing ones in the
+ * docker-compose.yaml file.
+ *
+ * @param props.projectId - The project ID.
+ * @param props.envVars - The environment variables to add to the
+ * docker-compose.yaml
+ * @raises When called if there are no services in a docker-compose.yaml file
+ */
+export async function updateEnvVarsInternal(props: {
+  projectId: string;
+  envVars: EnvVars;
+}): Promise<void> {
+  const { projectId, envVars } = props;
+  const outputEnvVars = await getAllEnvVarsInternal({ projectId });
+  Object.keys(envVars).forEach((service) => {
+    if (service in outputEnvVars) {
+      // Merge and update existing env vars with new ones
+      outputEnvVars[service] = {
+        ...outputEnvVars[service],
+        ...envVars[service]
+      };
+    } else {
+      // Set env vars to new ones for service
+      outputEnvVars[service] = envVars[service];
+    }
+  });
+  logger.debug(`applying envVarUpdate: ${JSON.stringify(outputEnvVars)}`);
+  await setEnvVarsInternal({ projectId, envVars: outputEnvVars });
+}

package/src/application-control/index.ts

@@ -1,30 +1,30 @@
+import { rollbackApp } from './backup';
 import { readAppCfgFile, updateAppCfg } from './config';
+import { getAllEnvVars, setEnvVars } from './environment-variables';
 import { installApp, uninstallApp } from './install';
-import { rollbackApp } from './backup';
 import {
+  getAppLogs,
   getAppState,
+  restartApp,
   startApp,
-  getAppLogs,
-  stopApp,
-  restartApp
+  stopApp
 } from './status';
 import { ModelDetails } from './types';
-import { getAllEnvs, setEnv } from './environment-variables';
 
 export {
-  readAppCfgFile,
-  updateAppCfg,
+  getAllEnvVars,
+  getAppLogs,
+  getAppState,
   installApp,
-  uninstallApp,
+  ModelDetails,
+  readAppCfgFile,
+  restartApp,
   rollbackApp,
-  getAppState,
+  setEnvVars,
   startApp,
-  getAppLogs,
   stopApp,
-  restartApp,
-  ModelDetails,
-  getAllEnvs,
-  setEnv
+  uninstallApp,
+  updateAppCfg
 };
 
 // CLI-mode only

package/src/application-control/install.ts

@@ -1,40 +1,39 @@
-import { rimraf } from 'rimraf';
-import * as fs from 'fs';
-import * as path from 'path';
-import { buildDockerImage } from 'alwaysai/lib/util/docker';
-import { JsSpawner, Spawner, stringifyError } from 'alwaysai/lib/util';
-import { getAppDir, buildApp } from './utils';
+import { AppConfig } from '@alwaysai/app-configuration-schemas';
 import { AppDetails, EnvVars } from '@alwaysai/device-agent-schemas';
-import { BACKUP_EXT } from './backup';
-import { startApp, stopApp, isAppStarted } from './status';
-import { AgentConfigFile } from '../infrastructure/agent-config';
-import { ProjectJsonFile } from 'alwaysai/lib/core/project';
+import { DOCKER_IMAGE_ID_INITIAL_VALUE } from 'alwaysai/lib/constants';
 import {
-  getTargetHardwareType,
-  AppJsonFile,
-  TargetJsonFile,
   appCleanDocker,
-  getPythonVenvPaths,
+  AppJsonFile,
   createPythonVenv,
+  getPythonVenvPaths,
+  getTargetHardwareType,
   installPythonReqs,
-  TargetHardware
+  TargetHardware,
+  TargetJsonFile
 } from 'alwaysai/lib/core/app';
-import { DOCKER_IMAGE_ID_INITIAL_VALUE } from 'alwaysai/lib/constants';
-import { runInDir } from '../util/run-in-dir';
-import { installModelsWithPresignedURLs } from './models';
-import { logger } from '../util/logger';
-import { updateAppCfgFile, writeAppCfgFile } from './config';
+import { ProjectJsonFile } from 'alwaysai/lib/core/project';
+import { DOCKERFILE, PYTHON_REQUIREMENTS_FILE_NAME } from 'alwaysai/lib/paths';
+import { JsSpawner, Spawner, stringifyError } from 'alwaysai/lib/util';
+import { buildDockerImage } from 'alwaysai/lib/util/docker';
+import * as fs from 'fs';
+import * as path from 'path';
+import { rimraf } from 'rimraf';
+import { ALWAYSAI_TARGET_HW_OVERRIDE, parseTargetHW } from '../environment';
+import { AgentConfigFile } from '../infrastructure/agent-config';
 import {
   LOCAL_CONNECTION_HOST,
   LOCAL_CONNECTION_PORT,
   LOCAL_CONNECTION_ROUTING_KEY
 } from '../local-connection/constants';
-import { DOCKERFILE, PYTHON_REQUIREMENTS_FILE_NAME } from 'alwaysai/lib/paths';
 import { downloadToFile } from '../util/file';
-import { ALWAYSAI_TARGET_HW_OVERRIDE, parseTargetHW } from '../environment';
-import { setEnvInternal } from './environment-variables';
-import { AppConfig } from '@alwaysai/app-configuration-schemas';
-import { CliTerseError } from '@alwaysai/alwayscli';
+import { logger } from '../util/logger';
+import { runInDir } from '../util/run-in-dir';
+import { BACKUP_EXT } from './backup';
+import { updateAppCfgFile, writeAppCfgFile } from './config';
+import { updateEnvVarsAndPassthroughInternal } from './environment-variables-and-passthrough-update';
+import { installModelsWithPresignedURLs } from './models';
+import { isAppStarted, startApp, stopApp } from './status';
+import { buildApp, getAppDir } from './utils';
 
 type SignedUrlPayloadType = {
   appInstallPayload: {
@@ -135,25 +134,28 @@ export async function installApp(props: {
     path.join(appDir, 'models')
   );
 
-  // See if there's appCfg or envVars in the transaction, and if so, apply it
+  // See if there's appCfg in the transaction, and if so, apply it
+  // NOTE: this must be done before buildApp to ensure the changes
+  // are in the docker image
 
   if (appCfg) {
     logger.debug(`applying appCfg: ${JSON.stringify(appCfg)}`);
     await writeAppCfgFile({ projectId, appCfg });
   }
 
-  if (envVars) {
-    logger.debug(`applying envVarUpdate: ${JSON.stringify(envVars)}`);
-    try {
-      await setEnvInternal({ projectId, envVars });
-    } catch (error) {
-      logger.error(`error is : ${error}`);
-    }
-  }
-
   await installAppBuildReqs({ appDir });
   await buildApp({ appDir });
 
+  // Update environment variables if passed in to the install
+  // and/or if the pass-through is being used.
+  // We are doing this after the buildApp step to ensure that the
+  // docker-compose.yaml file exists when we update the environment variables.
+  // Since buildApp builds the images, and environment variables are added
+  // to the container, this flow works so long as updateEnvVarsInternal is
+  // called before startApp (or specifically running 'docker compose up').
+
+  await updateEnvVarsAndPassthroughInternal(projectId, envVars);
+
   await AgentConfigFile().setAppInstalled({
     projectId,
     version: appReleaseHash

package/src/application-control/utils.ts

@@ -1,7 +1,6 @@
-import { compose } from '../docker/docker-compose';
 import * as path from 'path';
+import { compose } from '../docker/docker-compose';
 
-import { AgentConfigFile } from '../infrastructure/agent-config';
 import {
   getDockerComposeCmdForApp,
   TargetJsonFile,
@@ -9,11 +8,12 @@ import {
   writeDockerComposeFile,
   writeStandaloneDockerfile
 } from 'alwaysai/lib/core/app';
-import { runInDir } from '../util/run-in-dir';
-import { logger } from '../util/logger';
-import { APP_ROOT } from '../util/directories';
-import { JsSpawner } from 'alwaysai/lib/util/spawner';
 import { DOCKER_COMPOSE_FILE, TARGET_JSON_FILE_NAME } from 'alwaysai/lib/paths';
+import { JsSpawner } from 'alwaysai/lib/util/spawner';
+import { AgentConfigFile } from '../infrastructure/agent-config';
+import { APP_ROOT } from '../util/directories';
+import { logger } from '../util/logger';
+import { runInDir } from '../util/run-in-dir';
 
 export function getAppDir(projectId: string): string {
   return path.join(APP_ROOT, projectId);

package/src/cloud-connection/device-agent-message-handler.ts

@@ -24,6 +24,7 @@ import {
 } from '@alwaysai/device-agent-schemas';
 import {
   AppInstallResponseMessage,
+  AppVersionControlUpdateConfigPayload,
   ModelsInstallResponseMessage
 } from '@alwaysai/device-agent-schemas/lib/app-action-schema';
 import { DeviceActionMessage } from '@alwaysai/device-agent-schemas/lib/device-action-schema';
@@ -226,6 +227,7 @@ class AppVersionControlMessageHandler
   private handleAppVersionControl = async (
     payload:
       | AppVersionControlInstallPayload
+      | AppVersionControlUpdateConfigPayload
       | AppVersionControlUninstallPayload,
     txId: string
   ): Promise<boolean> => {

package/src/cloud-connection/shadow-handler.ts

@@ -24,18 +24,18 @@ import {
 } from '@alwaysai/device-agent-schemas/lib/shadow-schema';
 import { stringifyError } from 'alwaysai/lib/util';
 import {
-  getAllEnvs,
+  getAllEnvVars,
   readAppCfgFile,
-  setEnv,
+  setEnvVars,
   updateAppCfg
 } from '../application-control';
+import { pruneModels } from '../application-control/models';
 import { getSystemInformation } from '../device-control/device-control';
 import { logger } from '../util/logger';
+import { BaseHandler } from './base-message-handler';
+import { MessageHandler } from './message-dispatcher';
 import { Publisher } from './publisher';
 import { AppConfigModels, getAppCfgModelsDiff } from './shadow';
-import { pruneModels } from '../application-control/models';
-import { MessageHandler } from './message-dispatcher';
-import { BaseHandler } from './base-message-handler';
 
 export type AppConfigUpdate = {
   newAppCfg: AppConfig;
@@ -365,7 +365,7 @@ export class ShadowHandler {
 
   public async updateProjectShadow(projectId: string) {
     const appCfg = await readAppCfgFile({ projectId });
-    const envVars = await getAllEnvs({ projectId });
+    const envVars = await getAllEnvVars({ projectId });
 
     const toReport: ShadowProjectsUpdateAll = {
       [projectId]: {
@@ -391,8 +391,8 @@ export class ShadowHandler {
     projectId: string;
     envVars: EnvVars;
   }) {
-    await setEnv({ projectId, envVars });
-    const currentEnvs = await getAllEnvs({ projectId });
+    await setEnvVars({ projectId, envVars });
+    const currentEnvs = await getAllEnvVars({ projectId });
     this.publisher.publish(
       getShadowTopic(this.clientId, 'projects', 'update'),
       JSON.stringify(

package/src/environment.ts

@@ -15,9 +15,10 @@ export const ALWAYSAI_LOG_TO_CONSOLE = process.env.ALWAYSAI_LOG_TO_CONSOLE;
 export const ALWAYSAI_ANALYTICS_PASSTHROUGH = parseBoolean(
   process.env.ALWAYSAI_ANALYTICS_PASSTHROUGH
 );
+export const ALWAYSAI_EDGEIQ_PASSTHROUGH_ENV_VAR_NAME =
+  process.env.ALWAYSAI_EDGEIQ_PASSTHROUGH_ENV_VAR_NAME;
 export const ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS =
   process.env.ALWAYSAI_LIVE_UPDATES_TIMEOUT_MS;
-
 export const ALWAYSAI_LOCAL_CONNECTION_HOST =
   process.env.ALWAYSAI_LOCAL_CONNECTION_HOST;
 export const ALWAYSAI_LOCAL_CONNECTION_PORT =

package/src/local-connection/constants.ts

@@ -1,7 +1,8 @@
 import {
+  ALWAYSAI_EDGEIQ_PASSTHROUGH_ENV_VAR_NAME,
+  ALWAYSAI_LOCAL_CONNECTION_ANALYTICS_ROUTING_KEY,
   ALWAYSAI_LOCAL_CONNECTION_HOST,
-  ALWAYSAI_LOCAL_CONNECTION_PORT,
-  ALWAYSAI_LOCAL_CONNECTION_ANALYTICS_ROUTING_KEY
+  ALWAYSAI_LOCAL_CONNECTION_PORT
 } from '../environment';
 
 export const LOCAL_CONNECTION_HOST = ALWAYSAI_LOCAL_CONNECTION_HOST
@@ -14,3 +15,7 @@ export const LOCAL_CONNECTION_ROUTING_KEY =
   ALWAYSAI_LOCAL_CONNECTION_ANALYTICS_ROUTING_KEY
     ? ALWAYSAI_LOCAL_CONNECTION_ANALYTICS_ROUTING_KEY
     : 'edgeiq-analytics-publish';
+export const LOCAL_CONNECTION_PASSTHROUGH_ENV_VAR_NAME =
+  ALWAYSAI_EDGEIQ_PASSTHROUGH_ENV_VAR_NAME
+    ? ALWAYSAI_EDGEIQ_PASSTHROUGH_ENV_VAR_NAME
+    : 'ALWAYSAI_CONNECT_TO_DEVICE_AGENT';