@alwaysai/device-agent 1.4.0 → 1.5.0

package/src/infrastructure/agent-config.ts

@@ -58,26 +58,7 @@ const ALWAYSAI_CONFIG_DIR = join(homedir(), '.config', 'alwaysai');
 
 const AGENT_CONFIG_FILE_NAME = 'alwaysai.agent.json';
 
-export interface AgentJsonFileReturnType
-  extends ConfigFileSchemaReturnType<AgentConfig> {
-  name: string;
-  getApps: () => Promise<InstalledAppConfig[]>;
-  getReadyApps;
-  getApp;
-  isAppPresent;
-  isAppReady;
-  removeApp;
-  setAppInstalling;
-  setAppInstalled;
-  setAppUninstalled;
-  getAppVersion: (props: { projectId: string }) => Promise<string>;
-  setAppBackup;
-  getAppBackup;
-}
-
-export function AgentConfigFile(
-  dir = ALWAYSAI_CONFIG_DIR
-): AgentJsonFileReturnType {
+export function AgentConfigFile(dir = ALWAYSAI_CONFIG_DIR) {
   const path = join(dir, AGENT_CONFIG_FILE_NAME);
   const initialValue: AgentConfig = {
     applications: []
@@ -88,31 +69,14 @@ export function AgentConfigFile(
     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 && config.applications ? config.applications : [];
+    return config?.applications ? config.applications : [];
   }
 
   async function getReadyApps() {
     const config = configFile.read();
-    return config && config.applications
+    return config?.applications
       ? config.applications.filter((app) => {
           return app.ready;
         })
@@ -205,6 +169,23 @@ export function AgentConfigFile(
     }
   }
 
+  async function setAppUninstalling(props: { projectId: string }) {
+    const { projectId } = props;
+    const app = await getApp({ projectId });
+    if (app) {
+      await removeApp({ projectId });
+      const config = configFile.read();
+      config.applications.push({ ...app, ...{ ready: false } });
+      configFile.write(config);
+    } else {
+      // NOTE: we should never be setting an app as installed
+      // if it doesn't exist (setAppInstalling was never called)
+      throw new Error(
+        `App ${projectId} was not previously configured and could not be set to installed!`
+      );
+    }
+  }
+
   async function setAppUninstalled(props: { projectId: string }) {
     const { projectId } = props;
     await removeApp({ projectId });
@@ -235,9 +216,26 @@ export function AgentConfigFile(
   async function getAppBackup(props: { projectId: string }) {
     const { projectId } = props;
     const app = await getApp({ projectId });
-    if (app && app.backup) {
+    if (app?.backup) {
       return app.backup;
     }
     return null;
   }
+
+  return {
+    ...configFile,
+    name: AGENT_CONFIG_FILE_NAME,
+    getApps,
+    getReadyApps,
+    getApp,
+    isAppPresent,
+    isAppReady,
+    setAppInstalling,
+    setAppInstalled,
+    setAppUninstalling,
+    setAppUninstalled,
+    getAppVersion,
+    setAppBackup,
+    getAppBackup
+  };
 }

package/src/local-connection/rabbitmq-connection.ts

@@ -1,6 +1,6 @@
 import { logger } from '../util/logger';
 import sleep from '../util/sleep';
-import compose from 'docker-compose';
+import { compose } from '../docker/docker-compose';
 import * as YAML from 'yaml';
 
 import {
@@ -23,19 +23,19 @@ export async function checkRabbitMQContainerRunning() {
     return false;
   }
   const containerData = await compose.ps({ cwd: DEVICE_AGENT_CFG_PATH });
-  if (!(containerData === undefined)) {
+  if (containerData !== undefined) {
     const rabbitmqService = containerData.data.services[0];
     if (
-      rabbitmqService.name === rabbitMQContainerName &&
-      rabbitmqService.state === 'Up'
+      rabbitmqService?.name === rabbitMQContainerName &&
+      rabbitmqService.state.includes('Up')
     ) {
-      logger.debug('alwaysAI Local Connection is running');
+      logger.debug('alwaysAI Local Connection Container is up');
       return true;
     }
-    logger.debug('alwaysAI Local Connection is not running');
+    logger.debug('alwaysAI Local Connection Container is not up');
     return false;
   }
-  logger.warn('alwaysAI Local Connection container was undefined');
+  logger.warn('alwaysAI Local Connection Container is undefined');
   return false;
 }
 
@@ -97,7 +97,7 @@ export async function setupRabbitMQContainer() {
     }
   } catch (e) {
     logger.error(
-      `Unable to start alwaysAI Device Agent Local Connection Container:\n${e.messaage}`
+      `Unable to start alwaysAI Device Agent Local Connection Container:\n${e}`
     );
   }
 }

package/src/secure-tunneling/secure-tunneling.test.ts

@@ -11,14 +11,15 @@ import { downloadFile } from '../util/download-file';
 import { getArch, getDistribution, getOsVersion } from '../util/system-info';
 import {
   SecureTunnelHandlerSingleton,
-  SecureTunnelPortInfo,
-  SecureTunnelShadowDesRep,
   SecureTunnelShadowUpdateDelta
 } from './secure-tunneling';
 // import { JsSpawner } from 'alwaysai/lib/util/spawner';
 import { ChildProcess } from 'child_process';
 import { killDetachedProcess, runDetachedProcess } from './spawner-detached';
-
+import {
+  SecureTunnelPortInfo,
+  SecureTunnelShadowDescriptionReported
+} from '@alwaysai/device-agent-schemas';
 //-----------------------------------------------------------------------------
 // mocks
 //-----------------------------------------------------------------------------
@@ -173,11 +174,10 @@ describe('SecureTunnelHandlerSingleton', () => {
 
   function transformDeltaToUpdateReported(
     deltaMsg: SecureTunnelShadowUpdateDelta
-  ): SecureTunnelShadowDesRep {
+  ): SecureTunnelShadowDescriptionReported {
     const { version, state } = deltaMsg;
-    const reportedStateReported: SecureTunnelShadowDesRep = JSON.parse(
-      JSON.stringify(state)
-    );
+    const reportedStateReported: SecureTunnelShadowDescriptionReported =
+      JSON.parse(JSON.stringify(state));
     return reportedStateReported;
   }
 
@@ -671,16 +671,16 @@ describe('SecureTunnelHandlerSingleton', () => {
   //---------------------------------------------------------------------------
   // test secureTunnelNotifyHandler function
   //---------------------------------------------------------------------------
-  it('should start Secure Tunnel, given localproxy already downloaded and default shadow is not enabled, that is default SSH connection', async () => {
+  it('should start Secure Tunnel, given local proxy already downloaded and default shadow is not enabled, that is default SSH connection', async () => {
     // Arrange
     // --------------------------------------------------------------------
-    mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that localproxy already exists on file system
+    mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that local proxy already exists on file system
     const message: SecureTunnelNotifyMsg = {
       clientAccessToken: 'DefaultSSHConnection_001',
       region: 'us-west-2',
       services: ['SSH']
     };
-    const expectedLocalproxyArgs = [
+    const expectedLocalProxyArgs = [
       '--destination-app',
       '22',
       '--region',
@@ -709,12 +709,12 @@ describe('SecureTunnelHandlerSingleton', () => {
     expect(runDetachedProcess).toHaveBeenCalledTimes(1);
     expect(runDetachedProcess).toHaveBeenCalledWith(
       SECURE_TUNNEL_BIN_PATH,
-      expectedLocalproxyArgs
+      expectedLocalProxyArgs
     );
     expect(killDetachedProcess).not.toHaveBeenCalled();
   });
 
-  const testCasesForDIfferentLocalproxyEnv: [string, string, string][] = [
+  const testCasesForDIfferentLocalProxyEnv: [string, string, string][] = [
     // linuxDistro, osVersion, arch
     ['debian', '12', 'aarch64'],
     ['debian', '12', 'arm64'],
@@ -734,12 +734,12 @@ describe('SecureTunnelHandlerSingleton', () => {
     ['ubuntu', '23.10', 'amd64'],
     ['ubuntu', '23.10', 'arm64']
   ];
-  test.each(testCasesForDIfferentLocalproxyEnv)(
-    'should start Secure Tunnel, given localproxy downloaded needed and default shadow is not enabled, that is default SSH connection',
+  test.each(testCasesForDIfferentLocalProxyEnv)(
+    'should start Secure Tunnel, given local proxy downloaded needed and default shadow is not enabled, that is default SSH connection',
     async (linuxDistro: string, osVersion: string, arch: string) => {
       // Arrange
       // --------------------------------------------------------------------
-      mockJsSpawner.exists.mockResolvedValueOnce(false); // mock that localproxy does not exist on file system
+      mockJsSpawner.exists.mockResolvedValueOnce(false); // mock that local proxy does not exist on file system
       jest.mocked(getArch).mockResolvedValueOnce(arch);
       jest.mocked(getOsVersion).mockResolvedValueOnce(osVersion);
       jest.mocked(getDistribution).mockResolvedValueOnce(linuxDistro);
@@ -749,7 +749,7 @@ describe('SecureTunnelHandlerSingleton', () => {
         region: 'us-west-2',
         services: ['SSH']
       };
-      const expectedLocalproxyArgs = [
+      const expectedLocalProxyArgs = [
         '--destination-app',
         '22',
         '--region',
@@ -791,7 +791,7 @@ describe('SecureTunnelHandlerSingleton', () => {
       expect(runDetachedProcess).toHaveBeenCalledTimes(1);
       expect(runDetachedProcess).toHaveBeenCalledWith(
         SECURE_TUNNEL_BIN_PATH,
-        expectedLocalproxyArgs
+        expectedLocalProxyArgs
       );
       expect(killDetachedProcess).not.toHaveBeenCalled();
     }
@@ -891,8 +891,8 @@ describe('SecureTunnelHandlerSingleton', () => {
     async (message) => {
       // Arrange
       // --------------------------------------------------------------------
-      mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that localproxy already exists on file system
-      const expectedLocalproxyArgs = [
+      mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that local proxy already exists on file system
+      const expectedLocalProxyArgs = [
         '--destination-app',
         '22',
         '--region',
@@ -1003,8 +1003,8 @@ describe('SecureTunnelHandlerSingleton', () => {
       expect(actualReportedShadow).toEqual(updateReported);
       jest.clearAllMocks(); // after setting up the shadow, we need to reset mocks again
       jest.resetModules();
-      mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that localproxy already exists on file system
-      const expectedLocalproxyArgs = [
+      mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that local proxy already exists on file system
+      const expectedLocalProxyArgs = [
         '--destination-app',
         '22',
         '--region',
@@ -1128,8 +1128,8 @@ describe('SecureTunnelHandlerSingleton', () => {
       expect(actualReportedShadow).toEqual(updateReported);
       jest.clearAllMocks(); // after setting up the shadow, we need to reset mocks again
       jest.resetModules();
-      mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that localproxy already exists on file system
-      const expectedLocalproxyArgs = [
+      mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that local proxy already exists on file system
+      const expectedLocalProxyArgs = [
         '--destination-app',
         expectedPortMapping,
         '--region',
@@ -1158,7 +1158,7 @@ describe('SecureTunnelHandlerSingleton', () => {
       expect(runDetachedProcess).toHaveBeenCalledTimes(1);
       expect(runDetachedProcess).toHaveBeenCalledWith(
         SECURE_TUNNEL_BIN_PATH,
-        expectedLocalproxyArgs
+        expectedLocalProxyArgs
       );
       expect(killDetachedProcess).toHaveBeenCalledTimes(0);
     }
@@ -1192,8 +1192,8 @@ describe('SecureTunnelHandlerSingleton', () => {
     expect(beforeReportedShadow).toEqual(updateReported);
     jest.clearAllMocks(); // after setting up the shadow, we need to reset mocks again
     jest.resetModules();
-    mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that localproxy already exists on file system
-    const expectedLocalproxyArgs = [
+    mockJsSpawner.exists.mockResolvedValueOnce(true); // mock that local proxy already exists on file system
+    const expectedLocalProxyArgs = [
       '--destination-app',
       expectedPortMapping,
       '--region',

package/src/secure-tunneling/secure-tunneling.ts

@@ -14,32 +14,25 @@ import { downloadFile } from '../util/download-file';
 import { logger } from '../util/logger';
 import { getArch, getDistribution, getOsVersion } from '../util/system-info';
 import { killDetachedProcess, runDetachedProcess } from './spawner-detached';
+import {
+  SecureTunnelPortInfo,
+  SecureTunnelShadowDescriptionReported
+} from '@alwaysai/device-agent-schemas';
 
 enum SecureTunnelServiceType {
   SSH = 'SSH',
   HTTP = 'HTTP'
 }
 
-export type SecureTunnelPortInfo = {
-  enabled: boolean;
-  type: string;
-  ip: string;
-  port: number;
-};
-
-export type SecureTunnelShadowDesRep = {
-  st_ports: SecureTunnelPortInfo[];
-};
-
 export type SecureTunnelShadowState = {
-  reported?: SecureTunnelShadowDesRep;
-  desired?: SecureTunnelShadowDesRep;
+  reported?: SecureTunnelShadowDescriptionReported;
+  desired?: SecureTunnelShadowDescriptionReported;
 };
 
 export type SecureTunnelShadowUpdateDelta = {
   version: number;
   timestamp: number;
-  state: SecureTunnelShadowDesRep;
+  state: SecureTunnelShadowDescriptionReported;
   metadata?: any;
 };
 
@@ -54,7 +47,7 @@ type SecureTunnelProxyMap = {
   mapProcess: ChildProcess;
 };
 
-type SecureTunnelLocalproxyInfo = {
+type SecureTunnelLocalProxyInfo = {
   lpDstAccessKey: string;
   lpRegion: string;
   lpServices: string;
@@ -83,9 +76,9 @@ const ST_START_PORT_NUMBER = 5010;
  */
 export class SecureTunnelHandlerSingleton {
   private static instance: SecureTunnelHandlerSingleton;
-  private reported: SecureTunnelShadowDesRep;
+  private reported: SecureTunnelShadowDescriptionReported;
   private httpProxyMap: SecureTunnelProxyMap[];
-  private localproxyInfo: SecureTunnelLocalproxyInfo;
+  private localProxyInfo: SecureTunnelLocalProxyInfo;
 
   /**
    * Initializes private variables of SecureTunnel handler.
@@ -97,7 +90,7 @@ export class SecureTunnelHandlerSingleton {
       st_ports: [JSON.parse(JSON.stringify(defaultSecureTunnelPortInfo))]
     };
     this.httpProxyMap = [];
-    this.localproxyInfo = {
+    this.localProxyInfo = {
       lpDstAccessKey: '',
       lpRegion: '',
       lpServices: '',
@@ -147,15 +140,15 @@ export class SecureTunnelHandlerSingleton {
     };
     logger.debug(`httpProxyMap after : ${JSON.stringify(this.httpProxyMap)}`);
     logger.debug(`reported after     : ${JSON.stringify(this.reported)}`);
-    await this.stopLocalproxy();
+    await this.stopLocalProxy();
     logger.debug('<- SecureTunnelHandlerSingleton.destroy');
   }
 
   /**
    * Returns current state of SecureTunnel shadow
-   * @returns {SecureTunnelShadowDesRep} - reported state of the SecureTunnel shadow
+   * @returns {SecureTunnelShadowDescriptionReported} - reported state of the SecureTunnel shadow
    */
-  public getSecureTunnelShadow(): SecureTunnelShadowDesRep {
+  public getSecureTunnelShadow(): SecureTunnelShadowDescriptionReported {
     logger.debug('-> SecureTunnelHandlerSingleton.getSecureTunnelShadow');
     logger.debug(`reported: ${JSON.stringify(this.reported)}`);
     logger.debug('<- SecureTunnelHandlerSingleton.getSecureTunnelShadow');
@@ -165,11 +158,11 @@ export class SecureTunnelHandlerSingleton {
   /**
    * Updates current state of SecureTunnel shadow
    * @param {SecureTunnelShadowUpdateDelta} deltaMsg - delta message, which includes desired state of the SecureTunnel shadow
-   * @return {SecureTunnelShadowDesRep} update reported message to send back to AWS IoT device shadow
+   * @return {SecureTunnelShadowDescriptionReported} update reported message to send back to AWS IoT device shadow
    */
   public async syncShadowToDeviceState(
     deltaMsg: SecureTunnelShadowUpdateDelta
-  ): Promise<SecureTunnelShadowDesRep> {
+  ): Promise<SecureTunnelShadowDescriptionReported> {
     logger.debug('-> SecureTunnelHandlerSingleton.syncShadowToDeviceState');
     const { version, state } = deltaMsg;
     if (!state || typeof state.st_ports === 'undefined') {
@@ -216,7 +209,7 @@ export class SecureTunnelHandlerSingleton {
 
     // if all entries are disabled, we need also to kill local proxy
     if (this.reported.st_ports.every((portInfo) => !portInfo.enabled)) {
-      await this.stopLocalproxy();
+      await this.stopLocalProxy();
     }
 
     // need to order list in the same order as desired before sending back
@@ -237,15 +230,15 @@ export class SecureTunnelHandlerSingleton {
     logger.debug('-> SecureTunnelHandlerSingleton.secureTunnelNotifyHandler');
 
     try {
-      await this.stopLocalproxy();
+      await this.stopLocalProxy();
       this.processNotifyMessage(message);
       await this.downloadSecureTunnel();
-      await this.startLocalproxy();
+      await this.startLocalProxy();
     } catch (error) {
       logger.error(error);
     }
 
-    logger.info(`Local Proxy Started: ${JSON.stringify(this.localproxyInfo)}`);
+    logger.info(`Local Proxy Started: ${JSON.stringify(this.localProxyInfo)}`);
     logger.debug('<- SecureTunnelHandlerSingleton.secureTunnelNotifyHandler');
   }
 
@@ -389,60 +382,60 @@ export class SecureTunnelHandlerSingleton {
   }
 
   /**
-   * Starts SecureTunnel localproxy process
+   * Starts SecureTunnel localProxy process
    */
-  private async startLocalproxy(): Promise<void> {
-    logger.debug('-> SecureTunnelHandlerSingleton.startLocalproxy');
+  private async startLocalProxy(): Promise<void> {
+    logger.debug('-> SecureTunnelHandlerSingleton.startLocalProxy');
 
     const args = [
       '--destination-app',
-      this.localproxyInfo.lpServices,
+      this.localProxyInfo.lpServices,
       '--region',
-      this.localproxyInfo.lpRegion,
+      this.localProxyInfo.lpRegion,
       '--capath',
       AWS_ROOT_CERTIFICATE_FILE_PATH,
       '--local-bind-address',
       '0.0.0.0',
       '-t',
-      this.localproxyInfo.lpDstAccessKey
+      this.localProxyInfo.lpDstAccessKey
     ];
 
-    this.localproxyInfo.lpProcess = await runDetachedProcess(
+    this.localProxyInfo.lpProcess = await runDetachedProcess(
       SECURE_TUNNEL_BIN_PATH,
       args
     );
-    logger.debug('<- SecureTunnelHandlerSingleton.startLocalproxy');
+    logger.debug('<- SecureTunnelHandlerSingleton.startLocalProxy');
   }
 
   /**
-   * Stops SecureTunnel localproxy process
+   * Stops SecureTunnel local proxy process
    */
-  private async stopLocalproxy(): Promise<void> {
-    logger.debug('-> SecureTunnelHandlerSingleton.stopLocalproxy');
-    if (!this.localproxyInfo.lpProcess) {
-      logger.debug('No localproxy process running');
-      logger.debug('<- SecureTunnelHandlerSingleton.stopLocalproxy');
+  private async stopLocalProxy(): Promise<void> {
+    logger.debug('-> SecureTunnelHandlerSingleton.stopLocalProxy');
+    if (!this.localProxyInfo.lpProcess) {
+      logger.debug('No local proxy process running');
+      logger.debug('<- SecureTunnelHandlerSingleton.stopLocalProxy');
       return;
     }
 
     try {
       logger.debug(
-        `About to kill localproxy: ${this.localproxyInfo.lpDstAccessKey}`
+        `About to kill local proxy: ${this.localProxyInfo.lpDstAccessKey}`
       );
-      await killDetachedProcess(this.localproxyInfo.lpProcess, [
+      await killDetachedProcess(this.localProxyInfo.lpProcess, [
         SECURE_TUNNEL_BIN_PATH
       ]);
-      logger.debug('SUCCESS: killing localproxy process');
+      logger.debug('SUCCESS: killing local proxy process');
     } catch (e) {
-      logger.error('ERROR: killing localproxy process:', e);
+      logger.error('ERROR: killing local proxy process:', e);
     }
-    this.localproxyInfo = {
+    this.localProxyInfo = {
       lpDstAccessKey: '',
       lpRegion: '',
       lpServices: '',
       lpProcess: null
     };
-    logger.debug('<- SecureTunnelHandlerSingleton.stopLocalproxy');
+    logger.debug('<- SecureTunnelHandlerSingleton.stopLocalProxy');
   }
 
   /**
@@ -524,16 +517,16 @@ export class SecureTunnelHandlerSingleton {
       });
     }
 
-    this.localproxyInfo.lpDstAccessKey = clientAccessToken;
-    this.localproxyInfo.lpRegion = region;
-    this.localproxyInfo.lpServices = portMappingList.join(',');
+    this.localProxyInfo.lpDstAccessKey = clientAccessToken;
+    this.localProxyInfo.lpRegion = region;
+    this.localProxyInfo.lpServices = portMappingList.join(',');
     logger.debug(`reported =  ${JSON.stringify(this.reported.st_ports)}`);
-    logger.debug(`localproxyInfo =  ${JSON.stringify(this.localproxyInfo)}`);
+    logger.debug(`localProxyInfo =  ${JSON.stringify(this.localProxyInfo)}`);
     logger.debug('<- SecureTunnelHandlerSingleton.processNotifyMessage');
   }
 
   /**
-   * Downloads SecureTunnel localproxy, if it was not downloaded before
+   * Downloads SecureTunnel local proxy, if it was not downloaded before
    */
   private async downloadSecureTunnel(): Promise<void> {
     logger.debug('-> SecureTunnelHandlerSingleton.downloadSecureTunnel');
@@ -549,7 +542,7 @@ export class SecureTunnelHandlerSingleton {
       getOsVersion()
     ]);
 
-    logger.info('Downloading SecureTunnel localproxy ...');
+    logger.info('Downloading SecureTunnel local proxy ...');
     const url = `${aaiArtifactsBucketUrl}/securetunnel/${linuxDistro}/${osVersion}/${arch}/${SECURE_TUNNEL_BIN_NAME}`;
     await JsSpawner().mkdirp(join(AAI_DIR, SECURE_TUNNEL_BIN_DIR));
     await downloadFile({
@@ -585,8 +578,8 @@ export class SecureTunnelHandlerSingleton {
   }
 
   private sortPorts(
-    desired: SecureTunnelShadowDesRep
-  ): SecureTunnelShadowDesRep {
+    desired: SecureTunnelShadowDescriptionReported
+  ): SecureTunnelShadowDescriptionReported {
     logger.debug('-> SecureTunnelHandlerSingleton.sortPorts');
     const sortedPorts = JSON.parse(JSON.stringify(this.reported));
     sortedPorts.st_ports.sort((a, b) => {

package/src/subcommands/device/clean.ts

@@ -14,7 +14,7 @@ import {
 } from '../../local-connection/rabbitmq-connection';
 import { stopApp } from '../../application-control';
 import { LOCAL_CERT_AND_KEY_DIR } from 'alwaysai/lib/paths';
-import safeRimraf from '../../util/safe-rimraf';
+import { safeRimraf } from '../../util/file';
 
 export const cleanCliLeaf = CliLeaf({
   name: 'clean',

package/src/subcommands/device/get-info.ts

@@ -0,0 +1,49 @@
+import { CliLeaf } from '@alwaysai/alwayscli';
+import {
+  getCpuDetails,
+  getDiskDetails,
+  getMemDetails,
+  getSystemInformation
+} from '../../device-control/device-control';
+
+export const getInfoCliLeaf = CliLeaf({
+  name: 'get-info',
+  description: 'Get device info',
+  namedInputs: {},
+  async action(_, opts) {
+    const cpuDetails = await getCpuDetails();
+    const diskDetails = await getDiskDetails();
+    const memDetails = await getMemDetails();
+    const out = {
+      'CPU Utilization': `${
+        cpuDetails?.usedPerc && cpuDetails.temperature
+          ? `Used ${cpuDetails?.usedPerc?.toFixed(2)}%, Temperature ${
+              cpuDetails?.temperature
+            } °C`
+          : 'Unavailable'
+      }`,
+      'Disk Utilization': `${
+        diskDetails?.usedGb && diskDetails.freeGb
+          ? `${diskDetails?.usedGb} GB / ${
+              diskDetails?.usedGb + diskDetails?.freeGb
+            } GB`
+          : 'Unavailable'
+      }`,
+      'Memory Utilization': `${
+        memDetails?.usedMb && memDetails.freeMb
+          ? `${memDetails.usedMb} MB / ${
+              memDetails.usedMb + memDetails.freeMb
+            } MB`
+          : 'Unavailable'
+      }`
+    };
+    console.table(out);
+    const systemInfo = await getSystemInformation();
+    console.table(systemInfo.os);
+    console.table(systemInfo.cpu);
+    console.table(systemInfo.disk?.drives);
+    console.table(systemInfo.device);
+    console.table(systemInfo.network);
+    console.table(systemInfo.versions);
+  }
+});

package/src/subcommands/device/index.ts

@@ -1,9 +1,18 @@
 import { CliBranch } from '@alwaysai/alwayscli';
-import { getInfoCliLeaf, initCliLeaf, restartCliLeaf } from './device';
+import { getInfoCliLeaf } from './get-info';
 import { cleanCliLeaf } from './clean';
+import { initCliLeaf } from './init';
+import { restartCliLeaf } from './restart';
+import { refreshCliLeaf } from './refresh';
 
 export const deviceCliBranch = CliBranch({
   name: 'device',
   description: 'Manage current device',
-  subcommands: [initCliLeaf, getInfoCliLeaf, cleanCliLeaf, restartCliLeaf]
+  subcommands: [
+    initCliLeaf,
+    getInfoCliLeaf,
+    refreshCliLeaf,
+    cleanCliLeaf,
+    restartCliLeaf
+  ]
 });