@phystack/hub-device 4.3.40-dev

package/src/utilities/get-device-identifier.utility.ts

@@ -0,0 +1,179 @@
+
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import getSysinfo from '../sysinfo';
+import { v4 as uuidv4 } from 'uuid';
+
+const logger = console;
+
+function getSerialFromDmidecode(): string | undefined {
+  try {
+    // Execute the command using spawnSync
+    const result = spawnSync('sudo', ['dmidecode', '-s', 'system-serial-number'], {
+      encoding: 'utf-8',
+    });
+
+    // Get the device serial number and trim any whitespace
+    const deviceSerialNumber = result.stdout?.trim() || '';
+
+    // Check if the serial number is '0', empty, or contains spaces
+    if (
+      deviceSerialNumber === '0' ||
+      deviceSerialNumber === '' ||
+      deviceSerialNumber.includes(' ')
+    ) {
+      return undefined;
+    }
+
+    return deviceSerialNumber;
+  } catch (error) {
+    logger.info('No serial number in dmidecode, trying other options');
+    return undefined;
+  }
+}
+
+function getSerialFromKernelCmdline(): string | undefined {
+  try {
+    // Check ARM64 device tree boot args first (most reliable for ARM64 systems)
+    if (fs.existsSync('/proc/device-tree/chosen/bootargs')) {
+      const bootArgs = fs.readFileSync('/proc/device-tree/chosen/bootargs', 'utf8');
+      // Look for phygrid.serial=VALUE parameter in boot args
+      const bootArgsMatch = bootArgs.match(/phygrid\.serial=([^\s\0]+)/);
+      if (bootArgsMatch && bootArgsMatch[1]) {
+        return bootArgsMatch[1].trim();
+      }
+    }
+
+    // Fallback: Read kernel command line from /proc/cmdline (works on all architectures)
+    const cmdline = fs.readFileSync('/proc/cmdline', 'utf8');
+    // Look for phygrid.serial=VALUE parameter
+    const cmdlineMatch = cmdline.match(/phygrid\.serial=([^\s]+)/);
+    if (cmdlineMatch && cmdlineMatch[1]) {
+      return cmdlineMatch[1].trim();
+    }
+  } catch (error) {
+    logger.info('No serial number in kernel command line, trying other options');
+  }
+
+  return undefined;
+}
+
+function getSerialFromCPU(): string | undefined {
+  // Helper function to get the Rockchip serial number
+  const getRockchipSN = (buffer: Buffer, offset: number): string | undefined => {
+    // Extract and return the serial number as a hex string
+    const serialNumber = buffer.toString('hex', offset, offset + 16);
+    return serialNumber || undefined;
+  };
+
+  // Check if "/sys/bus/nvmem/devices/rockchip-otp0/nvmem" exists and try to read it
+  if (fs.existsSync('/sys/bus/nvmem/devices/rockchip-otp0/nvmem')) {
+    try {
+      const data = fs.readFileSync('/sys/bus/nvmem/devices/rockchip-otp0/nvmem');
+      return getRockchipSN(data, 10);
+    } catch (error) {
+      logger.info('No serial number in rockchip-otp0, trying other options');
+    }
+  }
+
+  // Check if "/sys/bus/nvmem/devices/rockchip-efuse0/nvmem" exists and try to read it
+  if (fs.existsSync('/sys/bus/nvmem/devices/rockchip-efuse0/nvmem')) {
+    try {
+      const data = fs.readFileSync('/sys/bus/nvmem/devices/rockchip-efuse0/nvmem');
+      return getRockchipSN(data, 7);
+    } catch (error) {
+      logger.info('No serial number in rockchip-efuse0, trying other options');
+    }
+  }
+
+  // Attempt to read the serial number from "/proc/cpuinfo"
+  try {
+    const cpuInfo = fs.readFileSync('/proc/cpuinfo', 'utf8');
+    const lines = cpuInfo.split('\n');
+
+    for (const line of lines) {
+      if (line.startsWith('Serial')) {
+        return line.slice(10, 26).trim();
+      }
+    }
+  } catch (error) {
+    logger.info('No serial number in /proc/cpuinfo, trying other options');
+  }
+
+  // Return undefined if the serial number couldn't be found
+  return undefined;
+}
+
+function getSerialFromMachineId(): string | undefined {
+  try {
+    // Check if /var/lib/dbus/machine-id exists and read it
+    if (fs.existsSync('/var/lib/dbus/machine-id')) {
+      const dbusMachineId = fs.readFileSync('/var/lib/dbus/machine-id', 'utf8').trim();
+
+      if (dbusMachineId && dbusMachineId.length === 32 && /^[0-9a-f]{32}$/i.test(dbusMachineId)) {
+        return dbusMachineId.toUpperCase();
+      }
+    }
+  } catch (error) {
+    logger.info('No machine-id found, trying other options');
+  }
+
+  return undefined;
+}
+
+export default async function getDeviceIdentifier() {
+  // In browser environment, skip system checks and return UUID
+  if (typeof window !== 'undefined') {
+    const generatedUuid = uuidv4();
+    logger.info('Browser environment detected, generating UUID:', generatedUuid);
+    return generatedUuid;
+  }
+  // Priority 1: Kernel command line (ONLY for QEMU ARM64 virt machines where SMBIOS doesn't work)
+  const serialFromKernel = getSerialFromKernelCmdline();
+  if (serialFromKernel && serialFromKernel !== '-' && serialFromKernel.trim() !== '') {
+    return serialFromKernel.trim();
+  }
+
+  // Priority 2: Dmidecode
+  const serialFromDmidecode = getSerialFromDmidecode();
+  if (serialFromDmidecode && serialFromDmidecode !== '-' && serialFromDmidecode.trim() !== '') {
+    return serialFromDmidecode.trim();
+  }
+
+  // Priority 3: Get from CPU
+  const serialFromCpu = getSerialFromCPU();
+  if (serialFromCpu && serialFromCpu !== '-' && serialFromCpu.trim() !== '') {
+    return serialFromCpu.trim();
+  }
+
+  // Priority 4: Machine ID (systemd-generated unique identifier)
+  const serialFromMachineId = getSerialFromMachineId();
+  if (serialFromMachineId && serialFromMachineId !== '-' && serialFromMachineId.trim() !== '') {
+    return serialFromMachineId.trim();
+  }
+
+  // Priority 5: MAC address of the first network interface that is either Ethernet or Wi-Fi
+  const { system = {}, net = [] } = await getSysinfo();
+
+  for (const iface of net) {
+    if ((iface.type === 'wired' || iface.type === 'wireless') &&
+        iface.mac && iface.mac !== '-' && iface.mac.trim() !== '') {
+      return iface.mac.trim();
+    }
+  }
+
+  // Priority 6: Serial (if valid)
+  if (system.serial && system.serial !== '-' && system.serial.trim() !== '') {
+    return system.serial.trim();
+  }
+
+  // Priority 7: UUID
+  if (system.uuid && system.uuid !== '-' && system.uuid.trim() !== '') {
+    return system.uuid.trim();
+  }
+
+  // If no valid identifier found or if it's '-', generate a UUID
+  const generatedUuid = uuidv4();
+  logger.info('No valid device identifier found, generating UUID:', generatedUuid);
+  return generatedUuid;
+}

package/src/utilities/get-hub-credentials.utility.ts

@@ -0,0 +1,56 @@
+import getStorage from '../storage';
+import getAxiosInstanceWithProxy from '@phystack/axios-proxy';
+
+const logger = console;
+
+const getHubCredentials = async (
+  apiUrl: string
+): Promise<{ accessKey: string; deviceId: string; phyhubUrl: string; region: string } | undefined> => {
+  console.log('getHubCredentials(): calling getAxiosInstanceWithProxy()');
+  const axios = await getAxiosInstanceWithProxy();
+  console.log('getHubCredentials(): axios', axios);
+  const storage = await getStorage();
+  const deviceSerial: string = await storage.get('deviceSerial');
+  let accessKey: string = await storage.get('accessKey');
+  let deviceId: string = await storage.get('deviceId');
+  let phyhubUrl: string = await storage.get('phyhubUrl');
+  let region: string = await storage.get('region');
+  if (accessKey && deviceId && phyhubUrl) {
+    return { accessKey, deviceId, phyhubUrl, region };
+  }
+
+  try {
+    logger.info(
+      `getHubCredentials(): Fetching hub credentials for device ${deviceSerial} [${apiUrl}/provision]`
+    );
+
+    const res = await axios.post(
+      `${apiUrl}/v1/provision`,
+      {
+        deviceSerial,
+      },
+    );
+
+    accessKey = res.data?.data?.accessKey;
+    deviceId = res.data?.data?._id;
+    phyhubUrl = res.data?.data?.parentDevice?.phyhubUrl;
+    region = res.data?.data?.parentDevice?.region;
+    if (!accessKey || !deviceId || !phyhubUrl || !region) {
+      throw new Error(`Credentials missing missing from response: ${JSON.stringify(res.data ?? {})}`)
+    }
+    await storage.set('accessKey', accessKey);
+    await storage.set('deviceId', deviceId);
+    await storage.set('phyhubUrl', phyhubUrl);
+    await storage.set('region', region);
+    logger.info(`getHubCredentials(): Device ${deviceId} provisioned  🟢-🟢-⚪-⚪-⚪`);
+    return { accessKey, deviceId, phyhubUrl, region };
+  } catch (err: any) {
+    logger.error(
+      `getHubCredentials(): Cannot fetch hub credentials for device ${deviceSerial} [${apiUrl}/provision]  🟢-🔴-⚪-⚪-⚪`,
+      err.toString()
+    );
+    return undefined;
+  }
+};
+
+export default getHubCredentials;

package/src/utilities/get-provisioning-code.utility.ts

@@ -0,0 +1,55 @@
+import getStorage from '../storage';
+import getAxiosInstanceWithProxy from '@phystack/axios-proxy';
+
+const logger = console;
+
+const getProvisioningCode = async (apiUrl: string): Promise<any> => {
+  const axios = await getAxiosInstanceWithProxy();
+  const storage = await getStorage();
+  const deviceSerial: string = await storage.get('deviceSerial');
+  const deviceId = await storage.get('deviceId');
+  const accessKey = await storage.get('accessKey');
+  const gridEnv = await storage.get('gridEnv') || 'PROD';
+
+  // If device is already provisioned, don't fetch new code
+  if (deviceId && accessKey) {
+    logger.info(`getProvisioningCode(): Device already provisioned, skipping code fetch`);
+    return undefined;
+  }
+
+  const lastProvisioningCheckKey = `lastProvisioningCheck_${gridEnv}`;
+  const provisioningCodeKey = `provisioningCode_${gridEnv}`;
+
+  const lastProvisioningCheck = await storage.get(lastProvisioningCheckKey);
+  const currentTime = Date.now();
+
+  // If we have a recent check (within last 4.5 minutes), use cached code
+  if (lastProvisioningCheck && (currentTime - parseInt(lastProvisioningCheck)) < 270000) {
+    const existingCode = await storage.get(provisioningCodeKey);
+    if (existingCode) {
+      logger.info(`getProvisioningCode(): Using cached provisioning code ${existingCode} for env ${gridEnv}`);
+      return { provisioningCode: existingCode, deviceSerial };
+    }
+  }
+
+  try {
+    const provisioningUrl = `${apiUrl}/v1/codes`;
+    const res = await axios.post(provisioningUrl, { deviceSerial });
+    const provisioningCode = res.data?.data?.code;
+    if (!provisioningCode) {
+      throw new Error(`Provisioning code missing from response: ${JSON.stringify(res.data ?? {})}`)
+    }
+    logger.info(`getProvisioningCode(): Fetched provisioning code ${provisioningCode} for env ${gridEnv} 🟢-🟢-🟢-⚪-⚪`);
+
+    // Store with environment-specific keys
+    await storage.set(provisioningCodeKey, provisioningCode);
+    await storage.set(lastProvisioningCheckKey, currentTime.toString());
+
+    return { provisioningCode, deviceSerial };
+  } catch (err: any) {
+    logger.error(`getProvisioningCode(): Cannot fetch provisioning code for env ${gridEnv} 🟢-🟢-🔴-⚪-⚪`, err.toString());
+    return undefined;
+  }
+}
+
+export default getProvisioningCode;

package/tsconfig.json

@@ -0,0 +1,45 @@
+{
+  "compilerOptions": {
+    "module": "NodeNext",
+    "target": "es2022",
+    "outDir": "dist",
+    "rootDir": "./src",
+    "baseUrl": "src",
+    "removeComments": true,
+    "moduleResolution": "NodeNext",
+    "sourceMap": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "alwaysStrict": true,
+    "allowJs": true,
+    "noEmitOnError": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitAny": true,
+    "noImplicitReturns": false,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "strictBindCallApply": true,
+    "strictNullChecks": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
+    "declarationDir": "dist",
+    "declarationMap": true,
+    "declaration": true,
+    "paths": {
+      "@/*": ["*"]
+    }
+    },
+  "include": [
+    "./src/**/*"
+, "src/__tests__"  ],
+  "exclude": [
+    "node_modules/**/*",
+    ".serverless/**/*",
+    ".webpack/**/*",
+    "_warmup/**/*",
+    "dist/**/*",
+    ".vscode/**/*",
+  ],
+}