@altronix/cli 0.7.2 → 0.7.3

package/dist/app.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+type Props = {
+    name: string | undefined;
+};
+export default function App({ name }: Props): React.JSX.Element;
+export {};

package/dist/app.js

@@ -0,0 +1,7 @@
+import React from 'react';
+import { Text } from 'ink';
+export default function App({ name = 'Stranger' }) {
+    return (React.createElement(Text, null,
+        "Hello, ",
+        React.createElement(Text, { color: "green" }, name)));
+}

package/dist/build.js

@@ -0,0 +1,491 @@
+import dotenv from "dotenv";
+import { Ajv } from "ajv";
+import path from "node:path";
+import fs from "node:fs";
+import cp from "node:child_process";
+import inquirer from "@inquirer/confirm";
+import { concat, concatMap, EMPTY, from, last, lastValueFrom, map, merge, mergeMap, Observable, of, share, tap, toArray, } from "rxjs";
+import { PassThrough } from "node:stream";
+import { render } from "ink";
+import React from "react";
+import Ui from "./build.ui.js";
+import { keys } from "./keys.js";
+const schemaBuild = {
+    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 schemaSeedle = {
+    type: "object",
+    required: [],
+    patternProperties: {
+        ".*": {
+            type: "object",
+            required: ["installDir", "files"],
+            properties: {
+                namespace: { type: "string", nullable: true },
+                prefix: { type: "string", nullable: true },
+                installDir: { type: "string" },
+                files: { type: "array", items: { type: "string" } },
+            },
+        },
+    },
+};
+const schema = {
+    type: "object",
+    required: ["applications", "bootloaders", "wasm"],
+    additionalProperties: false,
+    properties: {
+        applications: schemaBuild,
+        bootloaders: schemaBuild,
+        wasm: schemaSeedle,
+    },
+};
+const ajv = new Ajv({ allErrors: true, verbose: true });
+const validate = ajv.compile(schema);
+async function stat(path) {
+    return new Promise((resolve) => fs.stat(path, (err, stat) => {
+        if (err) {
+            resolve(false);
+        }
+        else {
+            resolve(stat);
+        }
+    }));
+}
+async function resolver(cwd) {
+    // NOTE this assumes atx-zdk is named in the west.yml file as either atx or
+    //      atx-zdk. The default case is atx-zdk. Most people never rename the
+    //      yaml. However, if somebody wants to rename atx-zdk repo in their
+    //      workspace. We can have atx.json() pass this name in and resolve it
+    //      that way
+    const project = path.resolve(cwd);
+    const workspace = path.resolve(cwd, "..");
+    const atx0 = path.resolve(cwd, "..", "atx");
+    const atx1 = path.resolve(cwd, "..", "atx-zdk");
+    const atx = (await stat(atx0)) ? atx0 : (await stat(atx1)) ? atx1 : project;
+    return (dir, from) => {
+        if (dir.startsWith("<workspace>")) {
+            return path.join(workspace, dir.substring(12));
+        }
+        else if (dir.startsWith("<project>")) {
+            return path.join(project, dir.substring(10));
+        }
+        else if (dir.startsWith("<atx>")) {
+            return path.join(atx, dir.substring(6));
+        }
+        else if (path.isAbsolute(dir)) {
+            return dir;
+        }
+        else {
+            return path.resolve(from || cwd, dir);
+        }
+    };
+}
+async function parseAppVersion(v) {
+    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) {
+    const { major, minor, patch, tweak, extra } = ver;
+    return extra.length
+        ? `${major}-${minor}-${patch}-${tweak}-${extra}`
+        : `${major}-${minor}-${patch}-${tweak}`;
+}
+async function westOptionsNormalize(board, config, build, cwd, verbose) {
+    const resolve = await resolver(cwd);
+    const name = build.__key;
+    const installDir = resolve(build.installDir);
+    const sourceDir = resolve(build.sourceDir);
+    const binaryDir = path.join(resolve(build.binaryDir), board, config.__key);
+    const versionFile = path.join(sourceDir, "VERSION");
+    const version = formatVersion(await parseAppVersion(versionFile));
+    const confs = config.configs
+        ? config.configs.map((f) => resolve(f, sourceDir))
+        : [];
+    const overlays = config.overlays
+        ? config.overlays.map((f) => resolve(f, sourceDir))
+        : [];
+    return {
+        name,
+        board,
+        config: config.__key,
+        cwd,
+        version,
+        sourceDir,
+        binaryDir,
+        installDir,
+        outputFile: path.join(binaryDir, "build.log"),
+        errorFile: path.join(binaryDir, "build.err"),
+        confs,
+        overlays,
+        verbose,
+    };
+}
+function westItem(opts) {
+    const { board, name, config, version } = opts;
+    return {
+        kind: "west",
+        name: `${board}-${name}-${config}-${version}`
+    };
+}
+function west(args) {
+    const { cwd, board, sourceDir, binaryDir, confs, overlays } = args;
+    const item = westItem(args).name;
+    return of([
+        `build`,
+        `-b ${board}`,
+        `-s ${sourceDir}`,
+        `-d ${binaryDir}`,
+        `--`,
+        `-DEXTRA_CONF_FILE="${[...confs].join(";")}"`,
+        `-DEXTRA_DTC_OVERLAY_FILE="${[...overlays].join(";")}"`,
+    ]).pipe(mergeMap((westArgs) => new Observable((subscriber) => {
+        const west = cp.spawn("west", westArgs, { cwd, shell: true });
+        const fout = fs.createWriteStream(args.outputFile);
+        const ferr = fs.createWriteStream(args.errorFile);
+        const out = new PassThrough();
+        west.stdout.pipe(fout);
+        west.stdout.pipe(out);
+        west.stderr.pipe(ferr);
+        west.on("error", (e) => {
+            subscriber.error(e);
+            fout.close();
+            ferr.close();
+            out.destroy();
+        });
+        west.on("exit", () => {
+            fout.close();
+            ferr.close();
+            out.destroy();
+            subscriber.next({ item, complete: true });
+            subscriber.complete();
+        });
+        out.on("data", (data) => subscriber.next({ item, output: data.toString() }));
+    })));
+}
+async function seedleOptionsNormalize(seedle, cwd, verbose) {
+    const name = seedle.__key;
+    const resolve = await resolver(cwd);
+    const types = resolve("<atx>/lib/atx/types.cddl");
+    const installDir = resolve(seedle.installDir);
+    const buildDir = path.join(installDir, name);
+    const files = [...seedle.files, types].map((file) => path.resolve(cwd, file));
+    return {
+        name: seedle.__key,
+        cwd,
+        installDir,
+        buildDir,
+        files,
+        cddl: path.join(installDir, name, `${name}.cddl`),
+        outputFile: path.join(installDir, `${name}-build.log`),
+        errorFile: path.join(installDir, `${name}-build.err`),
+        prefix: seedle.prefix || "",
+        namespace: seedle.namespace || "altronix",
+        verbose,
+    };
+}
+function seedle(opts) {
+    const { name, namespace, cddl, cwd, installDir } = opts;
+    const templatePath = path.resolve(cwd, "..", "seedle-template");
+    const seedlePath = path.resolve(cwd, "..", "seedle", "seedle");
+    return of([
+        "generate",
+        "--force",
+        `--destination=${installDir}`,
+        `--path=${templatePath}`,
+        `--name=${name}`,
+        "--overwrite",
+        `-dnamespace=${namespace}`,
+        `-dseedle-manifest-path=${seedlePath.replace(/\\/g, "\\\\")}`,
+        `-dcddl=${cddl.replace(/\\/g, "\\\\")}`,
+    ]).pipe(mergeMap((seedleArgs) => new Observable((subscriber) => {
+        const wasm = cp.spawn("cargo", seedleArgs, {
+            cwd: installDir,
+            shell: true,
+        });
+        const fout = fs.createWriteStream(opts.outputFile);
+        const ferr = fs.createWriteStream(opts.errorFile);
+        wasm.stdout.pipe(fout);
+        wasm.stderr.pipe(ferr);
+        wasm.on("error", (e) => {
+            subscriber.error(e);
+            fout.close();
+            ferr.close();
+        });
+        wasm.on("exit", () => {
+            fout.close();
+            ferr.close();
+            subscriber.next();
+            subscriber.complete();
+        });
+    })));
+}
+function cmakeItem(opts) {
+    const { name } = opts;
+    return { kind: "wasm", name };
+}
+function cmakeConfigure(opts) {
+    const { buildDir, outputFile, errorFile, } = opts;
+    const item = cmakeItem(opts).name;
+    return of([`-B${buildDir}`, `-S${buildDir}`]).pipe(mergeMap((cmakeArgs) => new Observable((subscriber) => {
+        const wasm = cp.spawn("cmake", cmakeArgs, {
+            cwd: buildDir,
+            shell: true,
+        });
+        const fout = fs.createWriteStream(outputFile);
+        const ferr = fs.createWriteStream(errorFile);
+        const out = new PassThrough();
+        wasm.stdout.pipe(fout);
+        wasm.stdout.pipe(out);
+        wasm.stderr.pipe(ferr);
+        wasm.on("error", (e) => {
+            subscriber.error(e);
+            fout.close();
+            ferr.close();
+            out.destroy();
+        });
+        wasm.on("exit", () => {
+            fout.close();
+            ferr.close();
+            out.destroy();
+            subscriber.next({ item, complete: true });
+            subscriber.complete();
+        });
+        out.on("data", (data) => subscriber.next({ item, output: data.toString() }));
+    })));
+}
+function cmakeBuild(opts) {
+    const { buildDir, outputFile, errorFile, } = opts;
+    const item = cmakeItem(opts).name;
+    return of([`--build`, `${buildDir}`, `--target`, ` wasm`]).pipe(mergeMap((cmakeArgs) => new Observable((subscriber) => {
+        const wasm = cp.spawn("cmake", cmakeArgs, {
+            cwd: buildDir,
+            shell: true,
+        });
+        const fout = fs.createWriteStream(outputFile);
+        const ferr = fs.createWriteStream(errorFile);
+        const out = new PassThrough();
+        wasm.stdout.pipe(fout);
+        wasm.stdout.pipe(out);
+        wasm.stderr.pipe(ferr);
+        wasm.on("error", (e) => {
+            subscriber.error(e);
+            fout.close();
+            ferr.close();
+            out.destroy();
+        });
+        wasm.on("exit", () => {
+            fout.close();
+            ferr.close();
+            out.destroy();
+            subscriber.next({ item, complete: true });
+            subscriber.complete();
+        });
+        out.on("data", (data) => subscriber.next({ item, output: data.toString() }));
+    })));
+}
+function cmake(opts) {
+    return concat(cmakeConfigure(opts), cmakeBuild(opts));
+}
+function emulateBytePages(board) {
+    return (board.startsWith("atsame54_xpro") ||
+        board.startsWith("netway4e1bt") ||
+        board.startsWith("netway4eb") ||
+        board.startsWith("netway5pq") ||
+        board.startsWith("oa2b"));
+}
+function extraApplicationConfs(extraConfs) {
+    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 extraBootloaderConfs(board, extraConfs) {
+    const key = process.env["ALTRONIX_RELEASE_KEY"];
+    if (!key)
+        throw new Error("missing ALTRONIX_RELEASE_KEY from environment");
+    const extraConfsData = emulateBytePages(board)
+        ? [
+            `CONFIG_BOOT_SIGNATURE_KEY_FILE="${key}"`,
+            `CONFIG_SOC_FLASH_SAM0_EMULATE_BYTE_PAGES=y`,
+        ]
+        : [`CONFIG_BOOT_SIGNATURE_KEY_FILE="${key}"`];
+    return from(fs.promises.writeFile(extraConfs, extraConfsData.join("\r\n")));
+}
+function copy() {
+    return (obs$) => obs$.pipe(mergeMap((opts) => {
+        const { src, dst } = opts;
+        return new Observable((subscriber) => {
+            fs.promises
+                .copyFile(src, dst)
+                .then(() => subscriber.next(opts))
+                .catch(() => subscriber.next({ ...opts, err: dst }))
+                .finally(() => subscriber.complete());
+        });
+    }));
+}
+function concatFiles(src, dest) {
+    return from(src).pipe(concatMap((src) => from(fs.promises.readFile(src, "ascii"))), toArray(), mergeMap((arr) => from(fs.promises.writeFile(dest, arr.join("\r\n")))));
+}
+function mkdir() {
+    return (obs$) => obs$.pipe(mergeMap((dir) => new Observable((subscriber) => {
+        fs.promises
+            .mkdir(dir, { recursive: true })
+            .then(() => subscriber.next())
+            .catch((e) => subscriber.error(e))
+            .finally(() => subscriber.complete());
+    })));
+}
+function rmdir(dir) {
+    return new Observable((subscriber) => {
+        fs.promises
+            .rm(dir, { recursive: true })
+            .then(() => subscriber.next(dir))
+            .catch((e) => subscriber.error(e))
+            .finally(() => subscriber.complete());
+    });
+}
+function exists() {
+    return (obs$) => obs$.pipe(mergeMap((dir) => new Observable((subscriber) => {
+        fs.promises
+            .stat(dir)
+            .then(() => subscriber.next(dir))
+            .catch(() => subscriber.next(undefined))
+            .finally(() => subscriber.complete());
+    })));
+}
+function confirm(force) {
+    return (obs$) => force
+        ? of(true)
+        : obs$.pipe(concatMap((dir) => from(inquirer({ message: `Delete ${dir}?` }))));
+}
+function throwIf(predicate, message) {
+    return tap((v) => {
+        if (predicate(v))
+            throw new Error(message);
+    });
+}
+function clean(force) {
+    return (obs$) => obs$.pipe(exists(), concatMap((dir) => {
+        return dir
+            ? of(dir).pipe(confirm(force), throwIf((confirm) => !confirm, "User rejected delete"), mergeMap((_) => rmdir(dir)), map(() => void 0))
+            : of(void 0);
+    }));
+}
+function tovoid() {
+    return (obs$) => obs$.pipe(map(() => void 0));
+}
+export async function build() {
+    const config = this.opts()["config"] || path.resolve("./", "atx.json");
+    const verbose = this.optsWithGlobals()["verbose"];
+    const cwd = path.resolve(path.dirname(config));
+    const data = await fs.promises.readFile(config, "ascii");
+    const atx = 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 = keys(atx.applications).flatMap((app) => {
+        return keys(app.boards).flatMap((board) => {
+            return keys(board).map((config) => westOptionsNormalize(board.__key, config, app, cwd, verbose));
+        });
+    });
+    const bootloaders = keys(atx.bootloaders).flatMap((app) => {
+        return keys(app.boards).flatMap((board) => {
+            return keys(board).map((config) => westOptionsNormalize(board.__key, config, app, cwd, verbose));
+        });
+    });
+    const wasm = keys(atx.wasm).map((w) => seedleOptionsNormalize(w, cwd, verbose));
+    let concurrent = this.opts()["concurrent"]
+        ? parseInt(this.opts()["concurrent"])
+        : Infinity;
+    let buildApps = this.opts()["application"];
+    let buildBoot = this.opts()["bootloader"];
+    let buildWasm = this.opts()["wasm"];
+    if (!(buildApps || buildBoot || buildWasm)) {
+        buildApps = buildBoot = buildWasm = true;
+    }
+    const apps$ = buildApps ? from(await Promise.all(apps)) : EMPTY;
+    const boot$ = buildBoot ? from(await Promise.all(bootloaders)) : EMPTY;
+    const wasm$ = buildWasm ? from(await Promise.all(wasm)) : EMPTY;
+    // Handle all the preliminary stuff before building
+    const ready$ = concat(merge(apps$.pipe(mergeMap(({ installDir: s, binaryDir: b }) => from([s, b]))), boot$.pipe(mergeMap(({ installDir: s, binaryDir: b }) => from([s, b]))), wasm$.pipe(map(({ installDir: dir }) => dir))).pipe(mkdir()), wasm$.pipe(map(({ name, installDir }) => path.join(installDir, name)), clean(this.opts()["yes"])), apps$.pipe(mergeMap(({ binaryDir }) => extraApplicationConfs(path.join(binaryDir, extraAppConfFile)))), boot$.pipe(mergeMap(({ board, binaryDir }) => extraBootloaderConfs(board, path.join(binaryDir, extraBootConfFile)))), wasm$.pipe(mergeMap(seedle)), wasm$.pipe(mergeMap(({ files, cddl: dest }) => concatFiles(files, dest)))).pipe(last(), share());
+    // Get an array of every build item.
+    const items$ = merge(apps$.pipe(map(westItem)), boot$.pipe(map(westItem)), wasm$.pipe(map(cmakeItem))).pipe(toArray());
+    // Run build commands for all bootloaders, applications and wasm concurrently
+    const build$ = merge(apps$.pipe(map(west)), boot$.pipe(map(west)), wasm$.pipe(map(cmake))).pipe(mergeMap((obs) => obs, concurrent), share());
+    // Install everything into installDir
+    const install$ = merge(apps$.pipe(map(({ name, config, version: ver, board, binaryDir, installDir: d }) => {
+        return {
+            src: path.join(binaryDir, "zephyr", "zephyr.signed.bin"),
+            dst: path.join(d, `${board}-${name}-${config}-${ver}.signed.bin`),
+        };
+    })), boot$.pipe(map(({ name, config, board, binaryDir, installDir: d }) => {
+        return {
+            src: path.join(binaryDir, "zephyr", "zephyr.bin"),
+            dst: path.join(d, `${board}-${name}-${config}.bin`),
+        };
+    }))).pipe(copy(), tovoid());
+    await lastValueFrom(ready$);
+    const items = await lastValueFrom(items$);
+    const renderer = render(React.createElement(Ui, { items: items, "progress$": build$ }));
+    await lastValueFrom(build$);
+    renderer.cleanup();
+    return lastValueFrom(install$);
+}

package/dist/build.ui.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { Observable } from 'rxjs';
+export interface BuildItem {
+    name: string;
+    kind: "west" | "wasm";
+}
+export interface BuildProgress<K extends string = string> {
+    item: K;
+    output?: string;
+    error?: string;
+    complete?: boolean;
+}
+export interface Options {
+    items: BuildItem[];
+    progress$: Observable<BuildProgress>;
+}
+export default function ({ items, progress$ }: Options): React.JSX.Element;

package/dist/build.ui.js

@@ -0,0 +1,62 @@
+import React, { useLayoutEffect, useState } from 'react';
+import { Box, Text } from "ink";
+import { scan } from 'rxjs';
+export default function ({ items, progress$ }) {
+    const [width, setWidth] = useState(0);
+    const progress = useBuildEffect(progress$, items.map(({ name }) => name));
+    useLayoutEffect(() => {
+        const width = items
+            .map(({ name }) => name)
+            .reduce(calculateItemWidth, 0);
+        setWidth(width);
+    }, [items]);
+    return (React.createElement(Box, { flexDirection: "column" }, items.map((item) => (React.createElement(Box, { key: item.name },
+        React.createElement(Box, { width: width, marginRight: 2 },
+            React.createElement(Text, { wrap: "truncate", bold: true }, item.name.padStart(width))),
+        React.createElement(Box, { width: 4, marginRight: 2 },
+            React.createElement(Text, { wrap: "truncate", bold: true, color: buildColor(item.kind) }, item.kind.toUpperCase().padStart(4))),
+        React.createElement(Text, { dimColor: !progressComplete(progress[item.name]), color: progressColor(progress[item.name]) }, progress[item.name]))))));
+}
+function buildColor(kind) {
+    return kind === "west" ? "blue" : "magenta";
+}
+function progressComplete(progress) {
+    return progress === "OK!";
+}
+function progressColor(progress) {
+    return progressComplete(progress) ? "green" : "white";
+}
+function initProgress(items) {
+    return items.reduce((acc, curr) => ({ ...acc, [curr]: "" }), {});
+}
+function calculateItemWidth(acc, next) {
+    return next.length > acc ? next.length : acc;
+}
+function progressInc(progress) {
+    if (progress.charAt(0) == "|") {
+        return "/";
+    }
+    else if (progress.charAt(0) == "/") {
+        return "-";
+    }
+    else if (progress.charAt(0) == "-") {
+        return "\\";
+    }
+    else {
+        return "|";
+    }
+}
+function progressReducer(acc, next) {
+    acc[next.item] = next.complete ? "OK!" : progressInc(acc[next.item]);
+    return acc;
+}
+function useBuildEffect(obs$, items) {
+    const [progress, setProgress] = useState(initProgress(items));
+    useLayoutEffect(() => {
+        const s = obs$
+            .pipe(scan(progressReducer, progress))
+            .subscribe(progress => setProgress({ ...progress }));
+        return () => s.unsubscribe();
+    }, [obs$, items]);
+    return progress;
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import meow from 'meow';
+import App from './app.js';
+const cli = meow(`
+	Usage
+	  $ cli
+
+	Options
+		--name  Your name
+
+	Examples
+	  $ cli --name=Jane
+	  Hello, Jane
+`, {
+    importMeta: import.meta,
+    flags: {
+        name: {
+            type: 'string',
+        },
+    },
+});
+render(React.createElement(App, { name: cli.flags.name }));

package/dist/index.js

@@ -0,0 +1,50 @@
+import { program } from "commander";
+import path from "path";
+import fs from "fs";
+import { build } from "./build.js";
+import { plugins } from "./plugin.js";
+import { fileURLToPath } from "url";
+// https://stackoverflow.com/questions/8817423/why-is-dirname-not-defined-in-node-repl
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+(async function main() {
+    // 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
+        .name("atx")
+        .description("build atx zdk projects")
+        .version(ver)
+        .option("-VV, --verbose", "extra logging");
+    // Scan command
+    /*
+    const ignore = 'node_modules;target;build;.git';
+    program
+        .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
+    // TODO - detect if west is available and fail early
+    program
+        .command("build")
+        .description("build atx zdk application")
+        .option("-c, --config <CONFIG>", "workspace config file")
+        .option("-C, --concurrent <NUMBER>", "how many builds to run concurrently")
+        .option("-A, --application", "build applications")
+        .option("-B, --bootloader", "build bootloaders")
+        .option("-W, --wasm", "build wasm")
+        .option("-y, --yes", "answer yes automatically")
+        .action(build);
+    // Load plugins
+    (await plugins()).forEach(({ plugin: _, path: __, description: ___ }) => { });
+    try {
+        await program.parseAsync();
+    }
+    catch (e) {
+        console.error(e);
+    }
+})();

package/dist/keys.d.ts

@@ -0,0 +1,6 @@
+export type WithKey<T> = T & {
+    __key: string;
+};
+export declare function keys<T>(map: {
+    [key: string]: T;
+}): WithKey<T>[];

package/dist/keys.js

@@ -0,0 +1,5 @@
+export function keys(map) {
+    return Object.keys(map)
+        .filter((key) => key !== "__key")
+        .map((key) => ({ ...map[key], __key: key }));
+}

package/dist/plugin.d.ts

@@ -0,0 +1,7 @@
+interface NpmLsResult {
+    plugin: string;
+    path: string;
+    description: string;
+}
+export declare function plugins(): Promise<NpmLsResult[]>;
+export {};