@alwaysai/device-agent 0.0.4 → 0.0.5

package/src/infrastructure/agent-config.ts

@@ -0,0 +1,217 @@
+import { ConfigFileSchema } from '@alwaysai/config-nodejs';
+import { JSONSchemaType } from 'ajv';
+import { homedir } from 'os';
+import { join } from 'path';
+import { ALWAYSAI_DEVICE_AGENT_MODE } from '../environment';
+
+export interface AppBackupConfig {
+  version: string;
+}
+
+export interface InstalledAppConfig {
+  projectId: string;
+  version: string;
+  ready: boolean;
+  backup?: AppBackupConfig;
+}
+
+export interface AgentConfig {
+  applications: InstalledAppConfig[];
+}
+
+const schema: JSONSchemaType<AgentConfig> = {
+  type: 'object',
+  properties: {
+    applications: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          projectId: { type: 'string' },
+          version: { type: 'string' },
+          ready: { type: 'boolean' },
+          backup: {
+            type: 'object',
+            nullable: true,
+            properties: {
+              version: { type: 'string' },
+            },
+            required: ['version'],
+            additionalProperties: true,
+          },
+        },
+        required: ['projectId', 'version', 'ready'],
+        additionalProperties: true,
+      },
+    },
+  },
+  required: ['applications'],
+  additionalProperties: true,
+};
+
+const ALWAYSAI_CONFIG_DIR = join(homedir(), '.config', 'alwaysai');
+
+const AGENT_CONFIG_FILE_NAME = 'alwaysai.agent.json';
+
+export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
+  const path = join(dir, AGENT_CONFIG_FILE_NAME);
+  const initialValue: AgentConfig = {
+    applications: [],
+  };
+  const configFile = ConfigFileSchema({
+    path,
+    schema,
+    initialValue,
+  });
+
+  return {
+    ...configFile,
+    name: AGENT_CONFIG_FILE_NAME,
+    getApps,
+    getReadyApps,
+    getApp,
+    isAppPresent,
+    isAppReady,
+    removeApp,
+    setAppInstalling,
+    setAppInstalled,
+    setAppUninstalled,
+    getAppVersion,
+    setAppBackup,
+    getAppBackup,
+  };
+
+  async function getApps() {
+    const config = configFile.read();
+    return config.applications;
+  }
+
+  async function getReadyApps() {
+    const config = configFile.read();
+    return config.applications.filter((app) => {
+      return app.ready;
+    });
+  }
+
+  async function getApp(props: { projectId: string }) {
+    const { projectId } = props;
+    const apps = await getApps();
+    for (const app of apps) {
+      if (app.projectId === projectId) {
+        return app;
+      }
+    }
+    return null;
+  }
+
+  async function isAppPresent(props: { projectId: string }): Promise<boolean> {
+    const { projectId } = props;
+    const app = await getApp({ projectId });
+    if (app) {
+      return true;
+    }
+    return false;
+  }
+
+  async function isAppReady(props: { projectId: string }): Promise<boolean> {
+    const { projectId } = props;
+    const app = await getApp({ projectId });
+    if (app && app.ready) {
+      return true;
+    }
+    return false;
+  }
+
+  async function removeApp(props: { projectId: string }) {
+    const { projectId } = props;
+    const config = configFile.read();
+    const newList = config.applications.filter((app) => {
+      return app.projectId !== projectId;
+    });
+    config.applications = newList;
+    configFile.write(config);
+  }
+
+  async function setAppInstalling(props: { projectId: string; version: string }) {
+    const { projectId, version } = props;
+    const app = await getApp({ projectId });
+    if (app) {
+      await removeApp({ projectId });
+      const config = configFile.read();
+      config.applications.push({
+        projectId,
+        version,
+        ready: false,
+      });
+      configFile.write(config);
+    } else {
+      const config = configFile.read();
+      config.applications.push({
+        projectId,
+        version,
+        ready: false,
+      });
+      configFile.write(config);
+    }
+  }
+
+  async function setAppInstalled(props: { projectId: string; version: string }) {
+    const { projectId, version } = props;
+    const app = await getApp({ projectId });
+    if (app) {
+      await removeApp({ projectId });
+      const config = configFile.read();
+      app.version = version;
+      config.applications.push({
+        projectId,
+        version,
+        ready: true,
+      });
+      configFile.write(config);
+    } else {
+      const config = configFile.read();
+      config.applications.push({
+        projectId,
+        version,
+        ready: true,
+      });
+      configFile.write(config);
+    }
+  }
+
+  async function setAppUninstalled(props: { projectId: string }) {
+    const { projectId } = props;
+    await removeApp({ projectId });
+  }
+
+  async function getAppVersion(props: { projectId: string }) {
+    const { projectId } = props;
+    const app = await getApp({ projectId });
+    if (!app) {
+      throw new Error(`App ${projectId} not installed`);
+    }
+    return app.version;
+  }
+
+  async function setAppBackup(props: { projectId: string }) {
+    const { projectId } = props;
+    const app = await getApp({ projectId });
+    if (!app) {
+      throw new Error(`Project ${projectId} not installed!`);
+    }
+    await removeApp({ projectId });
+    const config = configFile.read();
+    app.backup = { version: app.version };
+    config.applications.push(app);
+    configFile.write(config);
+  }
+
+  async function getAppBackup(props: { projectId: string }) {
+    const { projectId } = props;
+    const app = await getApp({ projectId });
+    if (app && app.backup) {
+      return app.backup;
+    }
+    return null;
+  }
+}

package/src/infrastructure/certificates-and-tokens.ts

@@ -0,0 +1,71 @@
+import { DeviceTokens, writeOrUpdateDeviceCfgFile } from 'alwaysai/lib/components/device';
+import { checkUserIsLoggedInComponent } from 'alwaysai/lib/components/user';
+import { LOCAL_AAI_CFG_DIR, LOCAL_CERT_AND_KEY_DIR } from 'alwaysai/lib/constants';
+import { checkPaidPlan } from 'alwaysai/lib/core/project';
+import {
+  CliRpcClient,
+  getDeviceCertificates,
+  IotRpcDevice,
+  refreshDevice,
+} from 'alwaysai/lib/infrastructure';
+import { JsSpawner, Spawner, writeCertificate, writeTokens } from 'alwaysai/lib/util';
+
+// NOTE: This is reimplemented from the CLI to work for local checks
+export async function getTargetHardwareUuid(spawner: Spawner) {
+  if (await spawner.exists('/var/lib/dbus/machine-id')) {
+    return await spawner.run({ exe: 'cat', args: ['/var/lib/dbus/machine-id'] });
+  }
+  if (await spawner.exists('/etc/machine-id')) {
+    return await spawner.run({ exe: 'cat', args: ['/etc/machine-id'] });
+  }
+  return await spawner.run({ exe: 'hostname' });
+}
+
+// NOTE: This closely follows the flow of deviceCheckAndUpdateComponent in the CLI
+export async function writeCertificateAndToken(props: { deviceUuid: string }) {
+  const { deviceUuid } = props;
+  await checkUserIsLoggedInComponent({ yes: true });
+  if (!(await checkPaidPlan())) {
+    throw new Error(`This action only supported for Enterprise alwaysAI accounts!`);
+  }
+  const device: IotRpcDevice = (await CliRpcClient().getDeviceByUUID({
+    uuid: deviceUuid,
+  })) as IotRpcDevice;
+  if (!device) {
+    throw new Error(`Device not found for deviceId=${deviceUuid}`);
+  }
+  // TODO: Update HW ID if not there
+  if (device.hardware_ids && device.hardware_ids !== '') {
+    const spawner = JsSpawner();
+    const hardwareId = await getTargetHardwareUuid(spawner);
+    if (hardwareId !== device.hardware_ids) {
+      throw new Error('Certificates not intended for this device!');
+    }
+  }
+  const response = await refreshDevice(device.uuid);
+  const tokens: DeviceTokens = {
+    deviceId: deviceUuid,
+    accessToken: response.accessToken,
+    refreshToken: response.refreshToken,
+    idToken: response.idToken,
+  };
+  const tokenSpawner = JsSpawner({ path: LOCAL_AAI_CFG_DIR });
+  await writeTokens({ spawner: tokenSpawner, tokens });
+  await writeOrUpdateDeviceCfgFile({ spawner: tokenSpawner });
+
+  let iotKeys = device.iot_keys;
+  if (!iotKeys) {
+    // there are no certificates, we need to generate new ones
+    console.log('Generating new certificate');
+    const response = await getDeviceCertificates(device.uuid, device.mode);
+    iotKeys = response.iotKeys;
+  }
+  const certSpawner = JsSpawner({ path: LOCAL_CERT_AND_KEY_DIR });
+  await writeCertificate({
+    spawner: certSpawner,
+    certificate: iotKeys.certificatePem,
+    privateKey: iotKeys.keyPair.PrivateKey,
+    rootCa: iotKeys.rootCA,
+  });
+  console.log('Updated tokens and certificate');
+}

package/src/{util → infrastructure}/urls.ts

@@ -1,5 +1,5 @@
-import { getSystemId } from 'alwaysai';
 import { CliTerseError } from '@alwaysai/alwayscli';
+import { getSystemId } from 'alwaysai/lib/infrastructure';
 
 export function getIoTCoreEndpointUrl() {
   let iotCoreEndpointUrl = '';

package/src/root.ts

@@ -3,16 +3,16 @@ const winston = require('winston');
 import { CliBranch } from '@alwaysai/alwayscli';
 
 import { subcommands } from './subcommands';
-import { ALWAYSAI_CLI_EXECUTABLE_NAME } from './constants';
+import { ALWAYSAI_LOG_LEVEL } from './environment';
 
 winston.configure({
-  level: process.env.AAI_LOG_LEVEL || 'info',
+  level: ALWAYSAI_LOG_LEVEL || 'info',
   transports: [new winston.transports.Console()],
   format: winston.format.simple(),
 });
 
 export const root = CliBranch({
-  name: ALWAYSAI_CLI_EXECUTABLE_NAME,
+  name: 'aai-agent',
   description: 'Manage your alwaysAI production device',
   subcommands,
 });

package/src/subcommands/app/app.ts

@@ -6,33 +6,31 @@ import {
 } from '@alwaysai/alwayscli';
 import {
   addModel,
+  getAllEnvs,
+  getAppLogs,
   getAppModels,
-  removeModel,
-  replaceModels,
-  updateModels,
-} from '../../application-control/models';
-import {
-  getInstalledApps,
+  getAppStatus,
   installApp,
-  uninstallApp,
-} from '../../application-control/install';
-import { rollbackApp } from '../../application-control/backup';
-import {
-  listAppReleases,
   listAppLatestRelease,
-  getAppStatus,
+  listAppReleases,
+  removeModel,
+  replaceModels,
+  restartApp,
+  rollbackApp,
+  setEnv,
   startApp,
-  getAppLogs,
   stopApp,
-  restartApp,
-} from '../../application-control/status';
+  uninstallApp,
+  updateModels,
+} from '../../application-control';
+import { AgentConfigFile } from '../../infrastructure/agent-config';
 
 export const listAppsCliLeaf = CliLeaf({
   name: 'list',
   description: 'List all installed apps',
   namedInputs: {},
   async action(_, opts) {
-    const apps = await getInstalledApps();
+    const apps = await AgentConfigFile().getApps();
     console.table(apps);
   },
 });
@@ -272,16 +270,17 @@ export const replaceModelsCliLeaf = CliLeaf({
       description: 'Project Id',
       required: true,
     }),
-    model: CliStringArrayInput({
+    models: CliStringArrayInput({
       description: 'One or more model IDs',
       required: true,
     }),
   },
   async action(_, opts) {
-    const { project, model } = opts;
-    await replaceModels({ projectId: project, modelIds: model });
+    const { project, models } = opts;
+    await replaceModels({ projectId: project, modelIds: models });
   },
 });
+
 export const updateModelsCliLeaf = CliLeaf({
   name: 'update-models',
   description: 'Update all models for an alwaysAI app',
@@ -296,3 +295,42 @@ export const updateModelsCliLeaf = CliLeaf({
     await updateModels({ projectId: project });
   },
 });
+
+export const getAllEnvsCLiLeaf = CliLeaf({
+  name: 'get-all-envs',
+  description: 'Get environment variables for an application',
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+      required: true,
+    }),
+  },
+  async action(_, opts) {
+    const { project } = opts;
+    console.log(await getAllEnvs({ projectId: project }));
+  },
+});
+
+export const setEnvCLiLeaf = CliLeaf({
+  name: 'set-env',
+  description: 'Set environment variables for a service',
+  positionalInput: CliStringArrayInput({
+    placeholder: '<NAME=VALUE> [<NAME=VALUE> ...]',
+    required: true,
+  }),
+  namedInputs: {
+    project: CliStringInput({
+      description: 'Project Id',
+      required: true,
+    }),
+    service: CliStringInput({
+      description:
+        'The name of the docker-compose service to apply environment variable to',
+      required: false,
+    }),
+  },
+  async action(args, opts) {
+    const { project, service } = opts;
+    await setEnv({ projectId: project, vars: args, service });
+  },
+});

package/src/subcommands/app/index.ts

@@ -16,6 +16,8 @@ import {
   restartAppCliLeaf,
   replaceModelsCliLeaf,
   showAppModelsCliLeaf,
+  getAllEnvsCLiLeaf,
+  setEnvCLiLeaf,
 } from './app';
 
 export const appCliBranch = CliBranch({
@@ -38,5 +40,7 @@ export const appCliBranch = CliBranch({
     removeModelCliLeaf,
     replaceModelsCliLeaf,
     updateModelsCliLeaf,
+    getAllEnvsCLiLeaf,
+    setEnvCLiLeaf,
   ],
 });

package/src/subcommands/device/device.ts

@@ -0,0 +1,63 @@
+import { CliLeaf, CliStringInput } from '@alwaysai/alwayscli';
+import { checkUserIsLoggedInComponent } from 'alwaysai/lib/components/user';
+import { checkPaidPlan } from 'alwaysai/lib/core/project';
+import { addDevice, CliAuthenticationClient } from 'alwaysai/lib/infrastructure';
+import { JsSpawner } from 'alwaysai/lib/util';
+import { getCpuUtil, getDiskUtil, getMemUtil } from '../../device-control/device-control';
+import {
+  getTargetHardwareUuid,
+  writeCertificateAndToken,
+} from '../../infrastructure/certificates-and-tokens';
+
+export const initCliLeaf = CliLeaf({
+  name: 'init',
+  description: 'Initialize device',
+  namedInputs: {
+    name: CliStringInput({
+      description: 'Device name',
+      required: true,
+    }),
+    description: CliStringInput({
+      description: 'Device description',
+      required: false,
+    }),
+  },
+  async action(_, opts) {
+    const { name, description } = opts;
+    console.log('Initializing device');
+    await checkUserIsLoggedInComponent({ yes: true });
+    if (!(await checkPaidPlan())) {
+      throw new Error(`This action only supported for Enterprise alwaysAI accounts!`);
+    }
+    const { username } = await CliAuthenticationClient().getInfo();
+    const spawner = JsSpawner();
+    const hardwareId = await getTargetHardwareUuid(spawner);
+    const deviceToAdd = {
+      owner: username,
+      friendly_name: name,
+      host_name: '',
+      device_user_name: '',
+      description: description || '',
+      hardware_ids: hardwareId,
+      device_hash: '',
+      iotKeys: '',
+    };
+    const response = await addDevice(deviceToAdd, 'production');
+    await writeCertificateAndToken({ deviceUuid: response.deviceUUID });
+    console.log(`Initialized device as ${response.deviceUUID}`);
+  },
+});
+
+export const getInfoCliLeaf = CliLeaf({
+  name: 'get-info',
+  description: 'Get device info',
+  namedInputs: {},
+  async action(_, opts) {
+    const deviceInfo = [
+      ['CPU Utilization', `${String(await getCpuUtil())} %`],
+      ['Disk Utilization', `${String(await getDiskUtil())} %`],
+      ['Memory Utilization', `${String(await getMemUtil())} %`],
+    ];
+    console.table(deviceInfo);
+  },
+});

package/src/subcommands/device/index.ts

@@ -0,0 +1,8 @@
+import { CliBranch } from '@alwaysai/alwayscli';
+import { getInfoCliLeaf, initCliLeaf } from './device';
+
+export const deviceCliBranch = CliBranch({
+  name: 'device',
+  description: 'Manage current device',
+  subcommands: [initCliLeaf, getInfoCliLeaf],
+});

package/src/subcommands/get-model-package.ts

@@ -0,0 +1,60 @@
+import { CliLeaf, CliNumberInput, CliStringInput } from '@alwaysai/alwayscli';
+import { checkUserIsLoggedInComponent } from 'alwaysai/lib/components/user';
+import {
+  downloadModelPackageToCache,
+  ModelId,
+  modelPackageCache,
+} from 'alwaysai/lib/core/model';
+import { CliRpcClient } from 'alwaysai/lib/infrastructure';
+import { JsSpawner } from 'alwaysai/lib/util';
+import { join } from 'path';
+
+export const getModelPackageCliLeaf = CliLeaf({
+  name: 'get-model-package',
+  description: 'Download and unpack a model package',
+  positionalInput: CliStringInput({
+    description: 'For example, "alwaysai/mobilenet_ssd"',
+    required: true,
+    placeholder: '<id>',
+  }),
+  namedInputs: {
+    version: CliNumberInput({
+      description: 'The version number of the model',
+      required: false,
+    }),
+    path: CliStringInput({
+      description: 'The output path to write model package to',
+      required: false,
+    }),
+  },
+  async action(id, opts) {
+    // NOTE: This code closely follows 'get-model-package.ts' in the CLI
+    const { publisher, name } = ModelId.parse(id);
+    const path = opts.path ? opts.path : process.cwd();
+    // untar will unpack model package contents to <name> so append publisher to path
+    const publisherPath = join(path, publisher);
+    const spawner = JsSpawner({ path: publisherPath });
+
+    if (await spawner.exists(name)) {
+      console.log(
+        `Found existing version of ${id} at ${join(
+          publisherPath,
+          name,
+        )}, removing prior to download`,
+      );
+      spawner.rimraf(name);
+    }
+
+    console.log(`Downloading ${id} to ${path}`);
+    await checkUserIsLoggedInComponent({ yes: true });
+    const version =
+      opts.version || (await CliRpcClient().getModelVersion({ id })).version;
+    if (!modelPackageCache.has(id, version)) {
+      await downloadModelPackageToCache(id, version);
+    }
+    const modelPackageStream = modelPackageCache.read(id, version);
+    await spawner.mkdirp();
+    await spawner.untar(modelPackageStream);
+    console.log(`Completed downloading ${id} to ${path}`);
+  },
+});

package/src/subcommands/index.ts

@@ -1,5 +1,11 @@
-import { appCliBranch } from './app/index';
-import { getDeviceInfoCliLeaf } from './device-control';
+import { appCliBranch } from './app';
+import { deviceCliBranch } from './device';
 import { loginCliLeaf } from './login';
+import { getModelPackageCliLeaf } from './get-model-package';
 
-export const subcommands = [loginCliLeaf, appCliBranch, getDeviceInfoCliLeaf];
+export const subcommands = [
+  loginCliLeaf,
+  appCliBranch,
+  deviceCliBranch,
+  getModelPackageCliLeaf,
+];

package/src/subcommands/login.ts

@@ -1,4 +1,5 @@
 import { CliLeaf, CliStringInput, CliUsageError } from '@alwaysai/alwayscli';
+import { writeCertificateAndToken } from '../infrastructure/certificates-and-tokens';
 import { runCliCmd } from '../util/run-cli-cmd';
 
 export const loginCliLeaf = CliLeaf({
@@ -7,18 +8,24 @@ export const loginCliLeaf = CliLeaf({
   namedInputs: {
     email: CliStringInput({
       description: 'alwaysAI email',
+      required: true,
     }),
     password: CliStringInput({
       description: 'Account password',
+      required: true,
+    }),
+    device: CliStringInput({
+      description: 'The device UUID',
+      required: false,
     }),
   },
   async action(_, opts) {
-    const { email, password } = opts;
-    if (!email || !password) {
-      throw new CliUsageError('--email and --password are required!');
-    }
+    const { email, password, device } = opts;
     await runCliCmd({
       cmd: ['user', 'login', '--yes', '--email', email, '--password', password],
     });
+    if (device) {
+      await writeCertificateAndToken({ deviceUuid: device });
+    }
   },
 });

package/src/util/copy-dir.ts

@@ -1,4 +1,4 @@
-import { JsSpawner } from '../util/spawner/js-spawner';
+import { JsSpawner } from 'alwaysai/lib/util';
 
 export async function copyDir(props: { srcPath: string; destPath: string }) {
   const { srcPath, destPath } = props;

package/src/util/directories.ts

@@ -1,25 +1,25 @@
-import { join } from 'path';
 import {
-  CERT_AND_KEY_DIR,
-  TOKEN_DIR,
   DEVICE_CERTIFICATE_FILE_NAME,
   DEVICE_PRIVATE_KEY_FILE_NAME,
   DEVICE_ROOT_CERT_FILE_NAME,
   DEVICE_TOKEN_FILE_NAME,
-} from '../constants';
+  LOCAL_AAI_CFG_DIR,
+  LOCAL_CERT_AND_KEY_DIR,
+} from 'alwaysai/lib/constants';
+import { join } from 'path';
 
 export function getPrivateKeyFilePath() {
-  return join(CERT_AND_KEY_DIR, DEVICE_PRIVATE_KEY_FILE_NAME);
+  return join(LOCAL_CERT_AND_KEY_DIR, DEVICE_PRIVATE_KEY_FILE_NAME);
 }
 
 export function getCertificateFilePath() {
-  return join(CERT_AND_KEY_DIR, DEVICE_CERTIFICATE_FILE_NAME);
+  return join(LOCAL_CERT_AND_KEY_DIR, DEVICE_CERTIFICATE_FILE_NAME);
 }
 
 export function getRootCertificateFilePath() {
-  return join(CERT_AND_KEY_DIR, DEVICE_ROOT_CERT_FILE_NAME);
+  return join(LOCAL_CERT_AND_KEY_DIR, DEVICE_ROOT_CERT_FILE_NAME);
 }
 
 export function getCredentialsFilePath() {
-  return join(TOKEN_DIR, DEVICE_TOKEN_FILE_NAME);
+  return join(LOCAL_AAI_CFG_DIR, DEVICE_TOKEN_FILE_NAME);
 }

package/lib/constants.d.ts

@@ -1,13 +0,0 @@
-export declare const ALWAYSAI_CLI_EXECUTABLE_NAME = "aai-agent";
-export declare const DEVICE_TOKEN_FILE_NAME = "alwaysai.credentials.json";
-export declare const DEVICE_CONFIG_FILE_NAME = "alwaysai.config.json";
-export declare const TOKEN_DIR: string;
-export declare const CERT_AND_KEY_DIR: string;
-export declare const DEVICE_CERTIFICATE_FILE_NAME = "alwaysai.certificate.pem.crt";
-export declare const DEVICE_PRIVATE_KEY_FILE_NAME = "alwaysai.private.pem.key";
-export declare const DEVICE_PUBLIC_KEY_FILE_NAME = "alwaysai.public.pem.key";
-export declare const DEVICE_ROOT_CERT_FILE_NAME = "alwaysai.root.pem";
-export declare const SUPPORTED_JETPACK_VERSION = 4.4;
-export declare const JETPACK_IMAGE_LINK = "https://developer.nvidia.com/jetson-nano-sd-card-image-44";
-export declare const PLEASE_REPORT_THIS_ERROR_MESSAGE = "Please report this error message to support@alwaysai.co";
-//# sourceMappingURL=constants.d.ts.map

package/lib/constants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,4BAA4B,cAAc,CAAC;AAExD,eAAO,MAAM,sBAAsB,8BAA8B,CAAC;AAClE,eAAO,MAAM,uBAAuB,yBAAyB,CAAC;AAE9D,eAAO,MAAM,SAAS,QAAyC,CAAC;AAChE,eAAO,MAAM,gBAAgB,QAAkC,CAAC;AAEhE,eAAO,MAAM,4BAA4B,iCAAiC,CAAC;AAC3E,eAAO,MAAM,4BAA4B,6BAA6B,CAAC;AACvE,eAAO,MAAM,2BAA2B,4BAA4B,CAAC;AACrE,eAAO,MAAM,0BAA0B,sBAAsB,CAAC;AAE9D,eAAO,MAAM,yBAAyB,MAAM,CAAC;AAC7C,eAAO,MAAM,kBAAkB,8DAC8B,CAAC;AAE9D,eAAO,MAAM,gCAAgC,4DACc,CAAC"}