@altronix/cli 0.6.10 → 0.7.0

package/src/build.ts

@@ -0,0 +1,354 @@
+import dotenv from "dotenv";
+import { Ajv, JSONSchemaType } from "ajv";
+import { Command } from "commander";
+import path from "node:path";
+import fs from "node:fs";
+import cp from "node:child_process";
+import {
+  concat,
+  from,
+  lastValueFrom,
+  merge,
+  mergeMap,
+  Observable,
+  OperatorFunction,
+} from "rxjs";
+
+interface AtxConfig {
+  configs?: string[];
+  overlays?: string[];
+}
+interface AtxBoard {
+  [key: string]: AtxConfig;
+}
+
+interface AtxBuild {
+  sourceDir: string;
+  binaryDir: string;
+  installDir: string;
+  boards: { [key: string]: AtxBoard };
+}
+interface AtxWorkspace {
+  applications: { [key: string]: AtxBuild };
+  bootloaders: { [key: string]: AtxBuild };
+}
+
+const ajv = new Ajv({ allErrors: true, verbose: true });
+const schemaBuild: JSONSchemaType<{ [key: string]: AtxBuild }> = {
+  type: "object",
+  required: [],
+  patternProperties: {
+    ".*": {
+      type: "object",
+      required: ["sourceDir", "binaryDir", "installDir", "boards"],
+      properties: {
+        sourceDir: { type: "string" },
+        binaryDir: { type: "string" },
+        installDir: { type: "string" },
+        boards: {
+          type: "object",
+          required: [],
+          patternProperties: {
+            ".*": {
+              type: "object",
+              required: [],
+              patternProperties: {
+                ".*": {
+                  type: "object",
+                  properties: {
+                    configs: {
+                      type: "array",
+                      items: { type: "string" },
+                      nullable: true,
+                    },
+                    overlays: {
+                      type: "array",
+                      items: { type: "string" },
+                      nullable: true,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+};
+const schema: JSONSchemaType<AtxWorkspace> = {
+  type: "object",
+  required: ["applications", "bootloaders"],
+  additionalProperties: false,
+  properties: {
+    applications: schemaBuild,
+    bootloaders: schemaBuild,
+  },
+};
+const validate = ajv.compile(schema);
+
+interface Version {
+  major: number;
+  minor: number;
+  patch: number;
+  tweak: number;
+  extra: string;
+}
+async function parseAppVersion(v: string): Promise<Version> {
+  const data = await fs.promises.readFile(v, "ascii");
+  const reMajor = data.matchAll(/^VERSION_MAJOR = ([0-9]+)/gm).next();
+  const reMinor = data.matchAll(/^VERSION_MINOR = ([0-9]+)/gm).next();
+  const rePatch = data.matchAll(/^PATCHLEVEL = ([0-9]+)/gm).next();
+  const reTweak = data.matchAll(/^VERSION_TWEAK = ([0-9]+)/gm).next();
+  const reExtra = data.matchAll(/^EXTRAVERSION = ([.a-zA-Z-]+)/gm).next();
+
+  return {
+    major: reMajor.value ? parseInt(reMajor.value[1]) : 0,
+    minor: reMinor.value ? parseInt(reMinor.value[1]) : 0,
+    patch: rePatch.value ? parseInt(rePatch.value[1]) : 0,
+    tweak: reTweak.value ? parseInt(reTweak.value[1]) : 0,
+    extra: reExtra.value ? reExtra.value[1] : "",
+  };
+}
+
+function formatVersion(ver: Version): string {
+  const { major, minor, patch, tweak, extra } = ver;
+  return extra.length
+    ? `${major}-${minor}-${patch}-${tweak}-${extra}`
+    : `${major}-${minor}-${patch}-${tweak}`;
+}
+
+interface WestOptions {
+  cwd: string;
+  name: string;
+  board: string;
+  config: string;
+  version: string;
+  sourceDir: string;
+  binaryDir: string;
+  installDir: string;
+  outputFile: string;
+  errorFile: string;
+  confs: string[];
+  overlays: string[];
+}
+
+async function normalizeWestOptions(
+  appName: string,
+  boardName: string,
+  configName: string,
+  app: AtxBuild,
+  cwd: string
+) {
+  const resolve = (dir: string, from?: string) =>
+    path.isAbsolute(dir) ? dir : path.resolve(from || cwd, dir);
+  const sourceDir = resolve(app.sourceDir);
+  const binaryDir = path.join(resolve(app.binaryDir), boardName, configName);
+  const installDir = resolve(app.installDir);
+  const confs = app.boards[boardName][configName].configs || [];
+  const versionFile = path.join(sourceDir, "VERSION");
+  const version = formatVersion(await parseAppVersion(versionFile));
+  const overlays = [];
+  return {
+    name: appName,
+    board: boardName,
+    config: configName,
+    cwd,
+    version,
+    sourceDir,
+    binaryDir,
+    installDir,
+    outputFile: path.join(binaryDir, "build.log"),
+    errorFile: path.join(binaryDir, "build.err"),
+    confs,
+    overlays,
+  };
+}
+
+function extraApplicationConfs(extraConfs: string): Observable<void> {
+  const key = process.env["ALTRONIX_RELEASE_KEY"];
+  if (!key) throw new Error("missing ALTRONIX_RELEASE_KEY from environment");
+  const extraConfsData = [
+    `CONFIG_MCUBOOT_SIGNATURE_KEY_FILE="${key}"`,
+    `CONFIG_BOOTLOADER_MCUBOOT=y`,
+    `CONFIG_ATX_UPDATE_ENABLE=y`,
+  ].join("\r\n");
+  return from(fs.promises.writeFile(extraConfs, extraConfsData));
+}
+
+function emulateBytePages(board: string) {
+  return (
+    board.startsWith("atsame54_xpro") ||
+    board.startsWith("netway4e1bt") ||
+    board.startsWith("netway4eb") ||
+    board.startsWith("netway5pq") ||
+    board.startsWith("oa2b")
+  );
+}
+
+function extraBootloaderConfs(
+  board: string,
+  extraConfs: string
+): Observable<void> {
+  const key = process.env["ALTRONIX_RELEASE_KEY"];
+  if (!key) throw new Error("missing ALTRONIX_RELEASE_KEY from environment");
+  const extraConfsData = [`CONFIG_BOOT_SIGNATURE_KEY_FILE="${key}"`];
+  if (emulateBytePages(board)) {
+    extraConfsData.push(`CONFIG_SOC_FLASH_SAM0_EMULATE_BYTE_PAGES=y`);
+  }
+  return from(fs.promises.writeFile(extraConfs, extraConfsData.join("\r\n")));
+}
+
+function west(args: WestOptions): Observable<void> {
+  const { cwd, board, sourceDir, binaryDir, confs, overlays } = args;
+  const westArgs = [
+    `build`,
+    `-b ${board}`,
+    `-s ${sourceDir}`,
+    `-d ${binaryDir}`,
+    `--`,
+    `-DEXTRA_CONF_FILE="${[...confs].join(";")}"`,
+    `-DEXTRA_DTC_OVERLAY_FILE="${[...overlays].join(";")}"`,
+  ];
+
+  return new Observable((subscriber) => {
+    const west = cp.spawn("west", westArgs, { cwd, shell: true });
+    const fout = fs.createWriteStream(args.outputFile);
+    const ferr = fs.createWriteStream(args.errorFile);
+    west.stdout.pipe(fout);
+    west.stderr.pipe(ferr);
+    west.on("error", (e) => {
+      subscriber.error(e);
+      fout.close();
+      ferr.close();
+    });
+    west.on("exit", () => {
+      fout.close();
+      ferr.close();
+      subscriber.next();
+      subscriber.complete();
+    });
+  });
+}
+
+function installSignedBin(args: WestOptions): Observable<void> {
+  const { name, config, version, board, binaryDir, installDir: dir } = args;
+  const src = path.join(binaryDir, "zephyr", "zephyr.signed.bin");
+  const dst = path.join(
+    dir,
+    `${board}-${name}-${config}-${version}.signed.bin`
+  );
+  return new Observable((subscriber) => {
+    fs.promises
+      .copyFile(src, dst)
+      .then(() => subscriber.next())
+      .catch((e) => subscriber.error(e))
+      .finally(() => subscriber.complete());
+  });
+}
+
+function installBin(args: WestOptions): Observable<void> {
+  const { name, config, version, board, binaryDir, installDir: dir } = args;
+  const src = path.join(binaryDir, "zephyr", "zephyr.bin");
+  const dst = path.join(dir, `${board}-${name}-${config}-${version}.bin`);
+  return new Observable((subscriber) => {
+    fs.promises
+      .copyFile(src, dst)
+      .then(() => subscriber.next())
+      .catch((e) => subscriber.error(e))
+      .finally(() => subscriber.complete());
+  });
+}
+
+function mkdir(): OperatorFunction<string, void> {
+  return (obs$) =>
+    obs$.pipe(
+      mergeMap(
+        (dir) =>
+          new Observable<void>((subscriber) => {
+            fs.promises
+              .mkdir(dir, { recursive: true })
+              .then(() => subscriber.next())
+              .catch((e) => subscriber.error(e))
+              .finally(() => subscriber.complete());
+          })
+      )
+    );
+}
+
+interface RunBuildOptions {
+  install$: Observable<void>;
+  config$: Observable<void>;
+}
+function runBuild({
+  install$,
+  config$,
+}: RunBuildOptions): OperatorFunction<WestOptions, void> {
+  return (obs$) => {
+    // Create all the directories for our build
+    const dirs$ = obs$.pipe(
+      mergeMap(({ binaryDir, installDir }) => from([binaryDir, installDir])),
+      mkdir()
+    );
+    // Run west commands
+    const build$ = obs$.pipe(mergeMap((opts) => west(opts)));
+    return concat(dirs$, config$, build$, install$);
+  };
+}
+
+export async function build(this: Command): Promise<void> {
+  const config = this.opts().config || path.resolve("./", "atx.json");
+  const cwd = path.resolve(path.dirname(config));
+  const data = await fs.promises.readFile(config, "ascii");
+  const atx: AtxWorkspace = JSON.parse(data);
+  const extraAppConfFile = "application.conf";
+  const extraBootConfFile = "bootloader.conf";
+  if (!validate(atx)) throw validate.errors;
+  const env = path.resolve(cwd, ".env");
+  dotenv.config({ path: env });
+  const apps = Object.keys(atx.applications).flatMap((app) => {
+    return Object.keys(atx.applications[app].boards).flatMap((board) => {
+      return Object.keys(atx.applications[app].boards[board]).map((config) =>
+        normalizeWestOptions(app, board, config, atx.applications[app], cwd)
+      );
+    });
+  });
+
+  const bootloaders = Object.keys(atx.bootloaders).flatMap((app) => {
+    return Object.keys(atx.bootloaders[app].boards).flatMap((board) => {
+      return Object.keys(atx.bootloaders[app].boards[board]).map((config) =>
+        normalizeWestOptions(app, board, config, atx.bootloaders[app], cwd)
+      );
+    });
+  });
+
+  const apps$ = from(await Promise.all(apps));
+  const bootloaders$ = from(await Promise.all(bootloaders));
+  return lastValueFrom(
+    merge(
+      bootloaders$.pipe(
+        runBuild({
+          install$: bootloaders$.pipe(mergeMap((opts) => installBin(opts))),
+          config$: bootloaders$.pipe(
+            mergeMap(({ board, binaryDir }) =>
+              extraBootloaderConfs(
+                board,
+                path.join(binaryDir, extraBootConfFile)
+              )
+            )
+          ),
+        })
+      ),
+      apps$.pipe(
+        runBuild({
+          install$: apps$.pipe(mergeMap((opts) => installSignedBin(opts))),
+          config$: apps$.pipe(
+            mergeMap(({ binaryDir }) =>
+              extraApplicationConfs(path.join(binaryDir, extraAppConfFile))
+            )
+          ),
+        })
+      )
+    )
+  );
+}

package/src/index.ts

@@ -1,101 +1,40 @@
-import { log } from "@altronix/device";
 import { program } from "commander";
-import { getAbout, getSite, setSite } from "./about";
-import { getCloud, setCloud } from "./cloud";
-import { getNet, setDhcp, setNet } from "./net";
-import { reboot, save, saveAndReboot } from "./exe";
-import { update } from "./update";
-import { stress } from "./stress";
-import { listen } from "./listen";
+import path from "path";
+import fs from "fs";
+import * as seedle from "./seedle";
+import { build } from "./build";
 
 (async function main() {
-  log.info("running cli");
-
-  program.name("atx").description("access linq device via cli").version("TODO");
-
-  program
-    .command("get-about")
-    .description("get about data on the device")
-    .action(getAbout);
-
-  program
-    .command("get-site")
-    .description("get site id from the device")
-    .action(getSite);
-
-  program
-    .command("set-site")
-    .description("set site id from the device")
-    .argument("<site>", "new site id")
-    .action(setSite);
-
-  program
-    .command("get-net")
-    .description("get network configuration from the device")
-    .action(getNet);
-
-  program
-    .command("set-net")
-    .description("set network interface into static ip mode")
-    .argument("<ip>", "the new IP address")
-    .argument("<sn>", "the new SUBNET mask")
-    .argument("<gw>", "the new GATEWAY address")
-    .action(setNet);
-
-  program
-    .command("set-dhcp")
-    .description("set network interface into DHCP mode")
-    .action(setDhcp);
-
-  program
-    .command("get-cloud")
-    .description("get cloud endpoint on the device")
-    .action(getCloud);
-
-  program
-    .command("set-cloud")
-    .description("set cloud endpoint on the device")
-    .argument("<endpoint>", "cloud service location")
-    .action(setCloud);
-
-  program
-    .command("save")
-    .description("save data to persistant storage")
-    .action(save);
-
-  program
-    .command("save-reboot")
-    .description("save data to persistant storage and reboot the device")
-    .action(saveAndReboot);
-
-  program.command("reboot").description("reboot the device").action(reboot);
-
-  program
-    .command("erase")
-    .description("erase customer settings")
-    .action(reboot);
+  // Parse package.json to get version
+  const pkg = path.resolve(__dirname, "..", "package.json");
+  const ver = JSON.parse(await fs.promises.readFile(pkg, "ascii")).version;
+  const cwd = path.resolve("./");
 
   program
-    .command("stress")
-    .description("run a stress test on a device")
-    .argument("<count>", "how many requests to make")
-    .action(stress);
+    .name("atx")
+    .description("build atx zdk projects")
+    .version(ver);
 
+  // Scan command
+  const ignore = "node_modules;target;build;.git";
   program
-    .command("listen")
-    .description("listen for alerts and heartbeats")
-    .argument("<duration>", "how long to listen")
-    .action(listen);
+    .command("scan")
+    .description("scan for *.cddl files")
+    .option("-p, --path <PATH>", "root directory to start scan", cwd)
+    .option("-m, --matches <REGEX>", "match expression", ".*cddl$")
+    .option("-i, --ignores <REGEX>", "ignore directories", ignore)
+    .action(seedle.scan);
 
+  // Build command
   program
-    .command("update")
-    .description("run firmware update from file")
-    .argument("<file>", "file to update device with")
-    .action(update);
+    .command("build")
+    .description("build atx zdk application")
+    .option("-c, --config <CONFIG>", "workspace config file")
+    .action(build);
 
   try {
     await program.parseAsync();
   } catch (e) {
-    log.error(e.message, { ...e });
+    console.error(e);
   }
 })();

package/src/seedle.ts

@@ -0,0 +1,39 @@
+import { Command } from "commander";
+import path from "path";
+import fs from "fs";
+import dotenv from "dotenv";
+
+export async function scan(this: Command) {
+  // parse matches
+  const matches = this.opts()
+    .matches.split(";")
+    .map((s: string) => new RegExp(s, "g"));
+
+  // parse ignores
+  const ignores = this.opts()
+    .ignores.split(";")
+    .map((s: string) => new RegExp(s, "g"));
+
+  // parse start directory and load env.
+  const start = this.opts().path;
+  const env = path.join(start, ".env");
+  dotenv.config({ path: env });
+
+  // Log out matches
+  for await (const f of walk(start, matches, ignores)) {
+    console.log(f);
+  }
+}
+
+async function* walk(dir: string, matches: RegExp[], ignores: RegExp[]) {
+  for await (const d of await fs.promises.opendir(dir)) {
+    const entry = path.join(dir, d.name);
+    if (d.isDirectory()) {
+      const i = ignores.map((i) => entry.match(i)).filter((r) => r);
+      if (i.length == 0) yield* await walk(entry, matches, ignores);
+    } else if (d.isFile()) {
+      const m = matches.map((m) => entry.match(m)).filter((r) => r);
+      if (m.length > 0) yield entry;
+    }
+  }
+}

package/tsconfig.json

@@ -18,7 +18,7 @@
     "noUnusedParameters": true,
     "noImplicitAny": false,
     "noImplicitThis": false,
-    "strictNullChecks": false,
+    "strictNullChecks": true,
     "paths":{
       "@altronix/wasm/zdk": ["../wasm/zdk"]
     }