@altronix/cli 0.13.0 → 0.15.0

package/dist/build.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function build(this: Command): Promise<void>;

package/dist/build.js

@@ -0,0 +1,443 @@
+import dotenv from 'dotenv';
+import { Ajv } from 'ajv';
+import { parse as parseJsonc } from 'jsonc-parser';
+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, EmptyError, 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 schemaBoard = {
+    type: 'object',
+    required: ['images'],
+    properties: {
+        version: { type: 'string', nullable: true },
+        soc: { type: 'string', nullable: true },
+        cpu: { type: 'string', nullable: true },
+        variant: { type: 'string', nullable: true },
+        images: {
+            type: 'object',
+            required: [],
+            additionalProperties: {
+                type: 'object',
+                properties: {
+                    configs: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        nullable: true
+                    },
+                    overlays: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        nullable: true
+                    }
+                }
+            }
+        }
+    }
+};
+const schemaBuild = {
+    type: 'object',
+    required: [],
+    additionalProperties: {
+        type: 'object',
+        required: ['sourceDir', 'binaryDir', 'installDir', 'boards'],
+        properties: {
+            sourceDir: { type: 'string' },
+            binaryDir: { type: 'string' },
+            installDir: { type: 'string' },
+            boards: {
+                type: 'object',
+                required: [],
+                additionalProperties: {
+                    anyOf: [{ ...schemaBoard }, { type: 'array', items: schemaBoard }]
+                }
+            }
+        }
+    }
+};
+const schema = {
+    type: 'object',
+    required: ['applications', 'bootloaders'],
+    additionalProperties: false,
+    properties: {
+        applications: schemaBuild,
+        bootloaders: schemaBuild
+    }
+};
+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 major = data.matchAll(/^VERSION_MAJOR = ([0-9]+)/gm).next();
+    const minor = data.matchAll(/^VERSION_MINOR = ([0-9]+)/gm).next();
+    const patch = data.matchAll(/^PATCHLEVEL = ([0-9]+)/gm).next();
+    const tweak = data.matchAll(/^VERSION_TWEAK = ([0-9]+)/gm).next();
+    const extra = data.matchAll(/^EXTRAVERSION = ([\.a-zA-Z0-9-]+)/gm).next();
+    return {
+        major: (major.value && major.value[1] && parseInt(major.value[1])) || 0,
+        minor: (minor.value && minor.value[1] && parseInt(minor.value[1])) || 0,
+        patch: (patch.value && patch.value[1] && parseInt(patch.value[1])) || 0,
+        tweak: (tweak.value && tweak.value[1] && parseInt(tweak.value[1])) || 0,
+        extra: (extra.value && extra.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 boardTarget = [board.__key, board.soc, board.cpu, board.variant]
+        .filter((item) => !!item)
+        .join('/');
+    const installDir = resolve(build.installDir);
+    const sourceDir = resolve(build.sourceDir);
+    const binaryDir = path.join(resolve(build.binaryDir), boardTarget.replaceAll('/', '-'), 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: boardTarget.replaceAll('/', '-'),
+        boardTarget,
+        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',
+        item: `${board}-${name}-${config}-${version}`
+    };
+}
+function west(args) {
+    const { cwd, boardTarget, sourceDir, binaryDir, confs, overlays } = args;
+    const { item } = westItem(args);
+    const expect = path.join(binaryDir, 'zephyr', 'zephyr.bin');
+    return of([
+        `build`,
+        `-b ${boardTarget}`,
+        `-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();
+        const err = new PassThrough();
+        let error = '';
+        west.stdout.pipe(fout);
+        west.stdout.pipe(out);
+        west.stderr.pipe(ferr);
+        west.stderr.pipe(err);
+        west.on('error', (e) => {
+            fout.close();
+            ferr.close();
+            out.destroy();
+            err.destroy();
+            subscriber.next({ item, error: e.name });
+        });
+        west.on('exit', (_code) => {
+            fout.close();
+            ferr.close();
+            out.destroy();
+            err.destroy();
+            fs.stat(expect, (e) => {
+                e
+                    ? subscriber.next({ item, error })
+                    : subscriber.next({ item, complete: true });
+                subscriber.complete();
+            });
+        });
+        out.on('data', (d) => subscriber.next({ item, output: d.toString() }));
+        err.on('data', (d) => (error += d));
+    })));
+}
+function emulateBytePages(board) {
+    return (board.startsWith('same54_xpro') ||
+        board.startsWith('netway') ||
+        board.startsWith('oa2b'));
+}
+function extraAppConfs(extraConfs, config) {
+    const key = process.env['ALTRONIX_RELEASE_KEY'];
+    if (!key)
+        throw new Error('missing ALTRONIX_RELEASE_KEY from environment');
+    // Custom TLVs for partition identification embedded in the MCUboot image header.
+    // - 0x8001: partition index (1 = slot1_partition, where firmware updates are written)
+    // - 0x8002: partition name string
+    // Note: INT32 values use little-endian hex (1 -> 0x01000000) per imgtool convention.
+    const imgtoolArgs = [
+        '--custom-tlv 0x8001 0x01000000',
+        '--custom-tlv 0x8002 slot1_partition'
+    ].join(' ');
+    const extraConfsData = [
+        `CONFIG_MCUBOOT_SIGNATURE_KEY_FILE="${key}"`,
+        `CONFIG_BOOTLOADER_MCUBOOT=y`,
+        `CONFIG_ATX_UPDATE_ENABLE=y`,
+        `CONFIG_ATX_CONFIG="${config}"`,
+        `CONFIG_MCUBOOT_EXTRA_IMGTOOL_ARGS="${imgtoolArgs}"`
+    ].join('\r\n');
+    return from(fs.promises.writeFile(extraConfs, extraConfsData));
+}
+function extraBootConfs(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_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;
+        const promise = fs.promises
+            .copyFile(src, dst)
+            .then(() => opts)
+            .catch(() => ({ ...opts, err: dst }));
+        return from(promise);
+    }));
+}
+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(dir) {
+    return new Observable((subscriber) => {
+        fs.promises
+            .stat(dir)
+            .then(() => subscriber.next(true))
+            .catch(() => subscriber.next(false))
+            .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(concatMap((dir) => exists(dir).pipe(concatMap((exists) => {
+        return exists
+            ? of(dir).pipe(confirm(force), throwIf((confirm) => !confirm, 'User rejected delete'), mergeMap((_) => rmdir(dir)), map(() => dir))
+            : of(dir);
+    }))));
+}
+function tovoid() {
+    return (obs$) => obs$.pipe(map(() => void 0));
+}
+function filterExists(getPath) {
+    return (obs$) => obs$.pipe(mergeMap((item) => from(stat(getPath(item))).pipe(mergeMap((s) => (s ? of(item) : EMPTY)))));
+}
+function concatFiles(opts) {
+    const { inputs, output } = opts;
+    return from(Promise.all(inputs.map((f) => fs.promises.readFile(f)))
+        .then((buffers) => Buffer.concat(buffers))
+        .then((data) => fs.promises.writeFile(output, data)));
+}
+export async function build() {
+    const config = this.opts()['config'] || path.resolve('./', 'atx.json');
+    const verbose = this.optsWithGlobals()['verbose'];
+    const mBoard = new RegExp(this.opts()['matchesBoard'] || '(.*)');
+    const mApplication = new RegExp(this.opts()['matchesApplication'] || '(.*)');
+    const mConfig = new RegExp(this.opts()['matchesConfig'] || '(.*)');
+    const cwd = path.resolve(path.dirname(config));
+    const data = await fs.promises.readFile(config, 'ascii');
+    const atx = parseJsonc(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)
+        .filter(({ __key }) => __key.match(mApplication))
+        .flatMap((app) => {
+        return keys(app.boards)
+            .filter(({ __key }) => __key.match(mBoard))
+            .flatMap((board) => {
+            return keys(board.images)
+                .filter(({ __key }) => __key.match(mConfig))
+                .map((config) => {
+                return westOptionsNormalize(board, config, app, cwd, verbose);
+            });
+        });
+    });
+    const bootloaders = keys(atx.bootloaders).flatMap((app) => {
+        return keys(app.boards)
+            .filter(({ __key }) => __key.match(mBoard))
+            .flatMap((board) => {
+            return keys(board.images).map((config) => westOptionsNormalize(board, config, app, cwd, verbose));
+        });
+    });
+    let concurrent = this.opts()['concurrent']
+        ? parseInt(this.opts()['concurrent'])
+        : Infinity;
+    let buildApps = this.opts()['application'];
+    let buildBoot = this.opts()['bootloader'];
+    if (!(buildApps || buildBoot)) {
+        buildApps = buildBoot = true;
+    }
+    const apps$ = buildApps ? from(await Promise.all(apps)) : EMPTY;
+    const boot$ = buildBoot ? from(await Promise.all(bootloaders)) : 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])))).pipe(toArray(), mergeMap((arr) => from([...new Set(arr)])), // dedupe
+    clean(this.opts()['yes']), mkdir()), apps$.pipe(mergeMap(({ binaryDir, config }) => extraAppConfs(path.join(binaryDir, extraAppConfFile), config))), boot$.pipe(mergeMap(({ board, binaryDir }) => extraBootConfs(board, path.join(binaryDir, extraBootConfFile))))).pipe(last(), share());
+    // Get an array of every build item.
+    const items$ = merge(apps$.pipe(map(westItem)), boot$.pipe(map(westItem))).pipe(toArray());
+    // Run build commands for all bootloaders and applications concurrently
+    const build$ = merge(apps$.pipe(map(west)), boot$.pipe(map(west))).pipe(mergeMap((obs) => obs, concurrent), share());
+    // Create update.bin by concatenating signed binaries in the build dir
+    const update$ = apps$.pipe(mergeMap(({ binaryDir }) => {
+        const zephyrDir = path.join(binaryDir, 'zephyr');
+        const required = path.join(zephyrDir, 'zephyr.signed.bin');
+        const optional = [
+            path.join(zephyrDir, 'www.signed.bin'),
+            path.join(zephyrDir, 'packedfs.signed.bin')
+        ];
+        return from(optional).pipe(filterExists((f) => f), toArray(), mergeMap((extras) => concatFiles({
+            inputs: [required, ...extras],
+            output: path.join(zephyrDir, 'update.bin')
+        })));
+    }), tovoid());
+    // Install everything into installDir
+    const install$ = merge(apps$.pipe(mergeMap(({ name, config, version: ver, board, binaryDir, installDir: d }) => {
+        const prefix = `${board}-${name}-${config}-${ver}`;
+        const zephyrDir = path.join(binaryDir, 'zephyr');
+        // Required files (error if missing)
+        const required = [
+            {
+                src: path.join(zephyrDir, 'zephyr.signed.bin'),
+                dst: path.join(d, `${prefix}.signed.bin`)
+            },
+            {
+                src: path.join(zephyrDir, 'update.bin'),
+                dst: path.join(d, `${prefix}.update.bin`)
+            }
+        ];
+        // Optional files (skip if missing)
+        const optional = [
+            {
+                src: path.join(zephyrDir, 'www.bin'),
+                dst: path.join(d, `${prefix}.www.bin`)
+            },
+            {
+                src: path.join(zephyrDir, 'www.signed.bin'),
+                dst: path.join(d, `${prefix}.www.signed.bin`)
+            },
+            {
+                src: path.join(zephyrDir, 'packedfs.bin'),
+                dst: path.join(d, `${prefix}.packedfs.bin`)
+            },
+            {
+                src: path.join(zephyrDir, 'packedfs.signed.bin'),
+                dst: path.join(d, `${prefix}.packedfs.signed.bin`)
+            }
+        ];
+        const optional$ = from(optional).pipe(filterExists((opt) => opt.src));
+        return merge(from(required), optional$);
+    })), 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());
+    try {
+        await lastValueFrom(ready$);
+        const items = await lastValueFrom(items$);
+        const renderer = render(React.createElement(Ui, { items: items, "progress$": build$, onComplete: () => renderer.unmount() }));
+        await renderer.waitUntilExit();
+        renderer.cleanup();
+        return lastValueFrom(concat(update$, install$));
+    }
+    catch (e) {
+        if (!(e instanceof EmptyError))
+            throw e;
+        console.log('nothing to build');
+    }
+}

package/dist/build.ui.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { Observable } from 'rxjs';
+export declare class BuildError extends Error implements BuildItem {
+    item: string;
+    kind: 'west';
+    constructor(item: string, kind: 'west', message: string);
+}
+export interface BuildItem {
+    item: string;
+    kind: 'west';
+}
+export interface BuildProgress<K extends string = string> {
+    item: K;
+    output?: string;
+    error?: string;
+    complete?: boolean;
+}
+export interface Options {
+    items: BuildItem[];
+    progress$: Observable<BuildProgress>;
+    onComplete: BuildEffectCallback;
+}
+export default function ({ items, progress$, onComplete }: Options): React.JSX.Element;
+interface BuildEffectCallback<E extends Error = Error> {
+    (e?: E): void;
+}
+export {};

package/dist/build.ui.js

@@ -0,0 +1,95 @@
+import React, { useLayoutEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import { scan } from 'rxjs';
+import useStdoutDimensions from './useStdoutDimensions.js';
+export class BuildError extends Error {
+    constructor(item, kind, message) {
+        super(message);
+        Object.defineProperty(this, "item", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: item
+        });
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: kind
+        });
+    }
+}
+export default function ({ items, progress$, onComplete }) {
+    const [col, _rows] = useStdoutDimensions();
+    const [width, setWidth] = useState(0);
+    const progress = useBuildEffect(progress$, items.map(({ item: i }) => i), onComplete);
+    useLayoutEffect(() => {
+        const width = items.map(({ item }) => item).reduce(calculateItemWidth, 0);
+        setWidth(width);
+    }, [items]);
+    return (React.createElement(Box, { flexDirection: "column" }, items.map(({ item, kind }) => (React.createElement(Box, { key: item },
+        React.createElement(Box, { width: width, marginRight: 1 },
+            React.createElement(Text, { wrap: "truncate", bold: true }, item.padStart(width))),
+        React.createElement(Box, { width: 4, marginRight: 1 },
+            React.createElement(Text, { wrap: "truncate", bold: true, color: buildColor(kind) }, kind.toUpperCase().padStart(4))),
+        React.createElement(Box, { width: 2, marginRight: 1 }, progress[item] && React.createElement(Text, { color: "cyan" }, "=>")),
+        React.createElement(Box, { width: col - width - 4 - 2 - 1 - 1 - 1 },
+            React.createElement(Text, { wrap: "truncate", dimColor: !progressComplete(progress[item]), color: progressColor(progress[item]) }, progress[item])))))));
+}
+function buildColor(_kind) {
+    return 'blue';
+}
+function progressComplete(progress) {
+    return progress === 'OK!';
+}
+function progressColor(progress) {
+    return !progress ||
+        progress.charAt(0) == '|' ||
+        progress.charAt(0) == '/' ||
+        progress.charAt(0) == '-' ||
+        progress.charAt(0) == '\\'
+        ? 'white'
+        : progressComplete(progress)
+            ? 'green'
+            : 'red';
+}
+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!'
+        : next.error
+            ? next.error.replace(/\r?\n/g, '')
+            : progressInc(acc[next.item]);
+    return acc;
+}
+function useBuildEffect(obs$, items, cb) {
+    const [progress, setProgress] = useState(initProgress(items));
+    useLayoutEffect(() => {
+        const s = obs$.pipe(scan(progressReducer, progress)).subscribe({
+            next: (progress) => setProgress({ ...progress }),
+            complete: cb,
+            error: cb
+        });
+        return () => s.unsubscribe();
+    }, [obs$]);
+    return progress;
+}

package/dist/index.js

@@ -2,7 +2,8 @@
 import { program } from 'commander';
 import path from 'path';
 import fs from 'fs';
-import { build } from '@altronix/build';
+import { build } from './build.js';
+import { update } from './update.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));
@@ -16,17 +17,6 @@ program
     .version(ver)
     .option('-Q, --quiet', 'no logs')
     .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
@@ -36,123 +26,16 @@ program
     .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('--matches-board [regex]', 'board regex match expr')
     .option('--matches-application [regex]', 'application regex match expr')
     .option('--matches-config [regex]', 'config regex match expr')
     .option('-y, --yes', 'answer yes automatically')
     .action(build);
-// Device commands are optional - only available when @altronix/device can be loaded
-async function registerDeviceCommands() {
-    try {
-        // Test if device package is available
-        await import('@altronix/device');
-        // Dynamically import device-dependent modules
-        const { getAbout, getSite, setSite } = await import('./about.js');
-        const { reboot, save, saveAndReboot } = await import('./exe.js');
-        const { getNet, setNet, setDhcp } = await import('./net.js');
-        const { getCloud, setCloud } = await import('./cloud.js');
-        const { stress } = await import('./stress.js');
-        const { update } = await import('./update.js');
-        const { listen } = await import('./listen.js');
-        const { getDemo, getHello } = await import('./sample.js');
-        const { concurrent } = await import('./concurrent.js');
-        const device = program
-            .command('device')
-            .description('manage zephyr device settings')
-            .option('-p, --port <PORT>', 'listen port for incoming device connections')
-            .option('-v, --verbose', 'print extra debug informating during request')
-            .option('-f, --first', 'perform request on first device we see (any device)');
-        device
-            .command('get-about')
-            .description('get about data on the device')
-            .action(getAbout);
-        device
-            .command('get-site')
-            .description('get the site ID of the device')
-            .action(getSite);
-        device
-            .command('set-site')
-            .description('set the site ID of the device')
-            .argument('<site>', 'new site id')
-            .action(setSite);
-        device
-            .command('save')
-            .description('save data to persistant storage. (does not reboot)')
-            .action(save);
-        device
-            .command('reboot')
-            .description('reboot the device. (does not save)')
-            .action(reboot);
-        device
-            .command('save-reboot')
-            .description('save data to persistant storage and reboot the device')
-            .action(saveAndReboot);
-        device
-            .command('get-net')
-            .description('get network configuration from the device')
-            .action(getNet);
-        device
-            .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);
-        device
-            .command('set-dhcp')
-            .description('set network interface into DHCP mode')
-            .action(setDhcp);
-        device
-            .command('get-cloud')
-            .description('get cloud endpoint on the device')
-            .action(getCloud);
-        device
-            .command('set-cloud')
-            .description('set cloud endpoint on the device')
-            .argument('<endpoint>', 'cloud service location')
-            .action(setCloud);
-        device
-            .command('stress')
-            .description('run a stress test on a device')
-            .argument('<count>', 'how many requests to make')
-            .action(stress);
-        device
-            .command('update')
-            .description('run firmware update from file')
-            .argument('<file>', 'file to update device with')
-            .action(update);
-        device
-            .command('listen')
-            .description('listen for alerts and heartbeats')
-            .argument('<duration>', 'how long to listen')
-            .action(listen);
-        device
-            .command('concurrent')
-            .description('make a number of requests concurrently')
-            .argument('<count>', 'how many requests to make concurrently')
-            .action(concurrent);
-        const sample = program
-            .command('sample')
-            .description('manage zephyr device settings')
-            .option('-p, --port <PORT>', 'listen port for incoming device connections')
-            .option('-v, --verbose', 'print extra debug informating during request')
-            .option('-f, --first', 'perform request on first device we see (any device)');
-        sample
-            .command('get-demo')
-            .description('read the demo data from the sample')
-            .action(getDemo);
-        sample
-            .command('get-hello')
-            .description('read the hello data from the sample')
-            .action(getHello);
-    }
-    catch {
-        // Device package not available - device commands will not be registered
-    }
-}
-// Load plugins
-// (await plugins()).forEach(({ plugin: _, path: __, description: ___ }) => {});
-registerDeviceCommands()
-    .then(() => program.parseAsync())
-    .catch((e) => console.error(e));
+// Update command
+program
+    .command('update')
+    .description('inspect or flash firmware update')
+    .argument('<url>', 'target device URL (e.g., https://192.168.1.1:8008)')
+    .argument('<file>', 'path to update binary')
+    .action(update);
+program.parseAsync().catch((e) => console.error(e));

package/dist/keys.d.ts

@@ -0,0 +1,7 @@
+export type WithKey<T> = T & {
+    __key: string;
+};
+export type FlattenWithKey<Type> = Type extends Array<infer Item> ? Array<WithKey<Item>> : Array<WithKey<Type>>;
+export declare function keys<T>(map: {
+    [key: string]: T;
+}): FlattenWithKey<T>;

package/dist/keys.js

@@ -0,0 +1,14 @@
+export function keys(map) {
+    let ret = [];
+    Object.keys(map)
+        .filter((key) => key !== '__key')
+        .forEach((key) => {
+        if (Array.isArray(map[key])) {
+            map[key].forEach((item) => ret.push({ ...item, __key: key }));
+        }
+        else {
+            ret.push({ ...map[key], __key: key });
+        }
+    });
+    return ret;
+}

package/dist/plugin.js

@@ -1,7 +1,7 @@
 import cp from 'node:child_process';
 import path from 'node:path';
 import { filter, from, lastValueFrom, map, merge, mergeMap, Observable, of, toArray } from 'rxjs';
-import { keys } from '@altronix/build';
+import { keys } from './keys.js';
 function npmls(g) {
     return of(['ls', `${g ? '-g' : ''}`, '-l', '--json', '--depth 0']).pipe(mergeMap((args) => new Observable((subscriber) => {
         const ls = cp.spawn('npm', args, { shell: true });

package/dist/progress.ui.js

@@ -1,7 +1,7 @@
 import React, { useLayoutEffect, useState } from 'react';
 import { scan } from 'rxjs';
 import { Box, Text } from 'ink';
-import { useStdoutDimensions as useDimensions } from '@altronix/build';
+import useDimensions from './useStdoutDimensions.js';
 export default function Progress({ total, response$, onComplete }) {
     const [cols] = useDimensions();
     const [width, setWidth] = useState(Math.min(cols - 4, 76));

package/dist/update.d.ts

@@ -1,2 +1,42 @@
 import { Command } from 'commander';
-export declare function update(this: Command, file: string): Promise<void>;
+import { UpdateProgress } from './update.ui.js';
+/**
+ * Start flash operation - erases the partition
+ * GET /api/flash/start?partition=<name>
+ */
+export declare function flashStart(baseUrl: string, partition: string): Promise<void>;
+/**
+ * Transfer a single chunk
+ * PUT /api/flash/transfer?partition=<name>
+ * Body: CBOR-encoded [offset, data]
+ */
+export declare function flashTransfer(baseUrl: string, partition: string, offset: number, data: Uint8Array): Promise<void>;
+/**
+ * Complete the flash operation - triggers reboot
+ * GET /api/flash/transfer_complete?partition=<name>
+ */
+export declare function flashTransferComplete(baseUrl: string, partition: string): Promise<void>;
+/**
+ * Split image into 512-byte chunks, padding last chunk with 0xFF
+ */
+export declare function chunkImage(image: Uint8Array): Array<{
+    offset: number;
+    data: Uint8Array;
+}>;
+export type OnProgress = (progress: UpdateProgress) => void;
+export interface UploadImage {
+    partition: string;
+    image: Uint8Array;
+}
+/**
+ * Upload firmware to device
+ *
+ * For each partition:
+ *   1. Erase partition (GET /api/flash/start)
+ *   2. Transfer chunks (PUT /api/flash/transfer with CBOR [offset, data])
+ *
+ * After all partitions:
+ *   3. Finalize update (GET /api/flash/transfer_complete)
+ */
+export declare function uploadFirmware(baseUrl: string, images: UploadImage[], onProgress: OnProgress): Promise<void>;
+export declare function update(this: Command, url: string, file: string): Promise<void>;

package/dist/update.js

@@ -1,59 +1,161 @@
-import { Linq } from '@altronix/device';
-import { Update } from '@altronix/zdk/common';
-import { concat, defer, EmptyError, finalize, from, lastValueFrom, map, mergeScan, switchMap } from 'rxjs';
-import fs from 'fs';
-import logger from './logger.js';
-import { select, first } from './select.js';
-import progress from './progress.js';
-function chunks(data, size) {
-    let arr = [];
-    let remainder = data.length % size;
-    function slicer(n) {
-        for (let i = 0; i < n; i++) {
-            let idx = i * size;
-            arr.push(data.slice(idx, idx + size));
-        }
+import fs from 'node:fs';
+import https from 'node:https';
+import http from 'node:http';
+import { parseMcubootImages, AltronixImage } from '@altronix/webtobin';
+import * as CBOR from 'cbor2';
+import { render } from 'ink';
+import React from 'react';
+import UpdateUi from './update.ui.js';
+const CHUNK_SIZE = 512;
+// =============================================================================
+// OTA API
+// =============================================================================
+/**
+ * Make an HTTP/HTTPS request to the OTA API
+ */
+function otaRequest(method, baseUrl, path, partition, body) {
+    return new Promise((resolve, reject) => {
+        const url = new URL(path, baseUrl);
+        url.searchParams.set('partition', partition);
+        const isHttps = url.protocol === 'https:';
+        const transport = isHttps ? https : http;
+        const req = transport.request(url, {
+            method,
+            headers: body
+                ? {
+                    'Content-Type': 'application/cbor',
+                    'Content-Length': body.length,
+                }
+                : undefined,
+            rejectUnauthorized: false,
+        }, (res) => {
+            res.resume();
+            if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                resolve();
+            }
+            else {
+                reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+            }
+        });
+        req.on('error', reject);
+        if (body)
+            req.write(body);
+        req.end();
+    });
+}
+/**
+ * Start flash operation - erases the partition
+ * GET /api/flash/start?partition=<name>
+ */
+export function flashStart(baseUrl, partition) {
+    return otaRequest('GET', baseUrl, '/api/flash/start', partition);
+}
+/**
+ * Transfer a single chunk
+ * PUT /api/flash/transfer?partition=<name>
+ * Body: CBOR-encoded [offset, data]
+ */
+export function flashTransfer(baseUrl, partition, offset, data) {
+    const payload = new Uint8Array(CBOR.encode([offset, data]));
+    return otaRequest('PUT', baseUrl, '/api/flash/transfer', partition, payload);
+}
+/**
+ * Complete the flash operation - triggers reboot
+ * GET /api/flash/transfer_complete?partition=<name>
+ */
+export function flashTransferComplete(baseUrl, partition) {
+    return otaRequest('GET', baseUrl, '/api/flash/transfer_complete', partition);
+}
+// =============================================================================
+// Chunking
+// =============================================================================
+/**
+ * Split image into 512-byte chunks, padding last chunk with 0xFF
+ */
+export function chunkImage(image) {
+    const chunks = [];
+    for (let offset = 0; offset < image.length; offset += CHUNK_SIZE) {
+        const slice = image.subarray(offset, offset + CHUNK_SIZE);
+        const data = new Uint8Array(CHUNK_SIZE);
+        data.fill(0xff);
+        data.set(slice);
+        chunks.push({ offset, data });
     }
-    if (remainder == 0) {
-        slicer(data.length / size);
+    return chunks;
+}
+/**
+ * Upload firmware to device
+ *
+ * For each partition:
+ *   1. Erase partition (GET /api/flash/start)
+ *   2. Transfer chunks (PUT /api/flash/transfer with CBOR [offset, data])
+ *
+ * After all partitions:
+ *   3. Finalize update (GET /api/flash/transfer_complete)
+ */
+export async function uploadFirmware(baseUrl, images, onProgress) {
+    for (const { partition, image } of images) {
+        // Erase
+        onProgress({ partition, phase: 'erase' });
+        await flashStart(baseUrl, partition);
+        // Transfer chunks
+        const chunks = chunkImage(image);
+        for (let i = 0; i < chunks.length; i++) {
+            const { offset, data } = chunks[i];
+            await flashTransfer(baseUrl, partition, offset, data);
+            onProgress({
+                partition,
+                phase: 'transfer',
+                current: offset + CHUNK_SIZE,
+                total: image.length
+            });
+        }
+        // Mark complete
+        onProgress({ partition, phase: 'complete' });
     }
-    else {
-        let n = Math.ceil(data.length / size);
-        let end = size * (n - 1);
-        slicer(n - 1);
-        let last = new Uint8Array(size);
-        last.set(data.slice(end));
-        arr.push(last);
+    // Finalize (once, after all partitions)
+    if (images.length > 0) {
+        await flashTransferComplete(baseUrl, images[0].partition);
     }
-    return arr;
-}
-function updateMap(data, idx) {
-    let update = new Update({ data, offset: idx * 512 });
-    // NOTE: Have to initialize the Uint8Array across binding this way
-    // https://gitlab.altronix.com/software-engineering/sdk/atx-zdk/-/issues/1
-    update.data = data;
-    return update;
 }
-function updater(linq, serial) {
-    return (acc, update) => linq
-        .put(serial, '/api/v1/update/transfer', update.cbor())
-        .pipe(map(({ meta }) => ({ ...meta, remaining: acc.remaining - 1 })));
-}
-export async function update(file) {
-    logger(this.optsWithGlobals()['verbose'] ? 'silly' : 'info');
-    const linq = new Linq();
-    const dev$ = linq
-        .connections()
-        .pipe(this.optsWithGlobals()['first'] ? first() : select());
-    const obs = from(fs.promises.readFile(file)).pipe(switchMap((bin) => dev$.pipe(map((serial) => ({ serial, bin })))), switchMap(({ serial, bin }) => {
-        const update = chunks(bin, 512).map(updateMap);
-        const start$ = defer(() => linq.get(serial, '/api/v1/update/start'));
-        const finish$ = defer(() => linq.get(serial, '/api/v1/update/finish'));
-        const transfer$ = from(update).pipe(mergeScan(updater(linq, serial), { remaining: update.length }, 1));
-        return concat(start$, transfer$, finish$).pipe(progress(update.length));
-    }), finalize(() => linq.shutdown()));
-    return lastValueFrom(obs).catch((e) => {
-        if (!(e instanceof EmptyError))
-            throw e;
+// =============================================================================
+// CLI Command
+// =============================================================================
+export async function update(url, file) {
+    // Parse firmware file
+    const buffer = await fs.promises.readFile(file);
+    const bin = new Uint8Array(buffer);
+    const mcubootImages = parseMcubootImages(bin);
+    if (mcubootImages.length === 0) {
+        console.error('No valid MCUboot images found in file');
+        process.exit(1);
+    }
+    // Extract partition data
+    const images = mcubootImages.map((img) => {
+        const altronix = AltronixImage.fromMcubootImage(img);
+        return {
+            partition: altronix.partitionName,
+            image: altronix.signedImage
+        };
+    });
+    // Build UI items
+    const items = mcubootImages.map((img) => {
+        const altronix = AltronixImage.fromMcubootImage(img);
+        const { major, minor, revision, build } = altronix.version;
+        return {
+            partition: altronix.partitionName,
+            version: `${major}.${minor}.${revision}+${build}`,
+            size: altronix.signedImage.length
+        };
     });
+    // Render UI - it handles the upload internally
+    const renderer = render(React.createElement(UpdateUi, { baseUrl: url, items: items, images: images, onComplete: (error) => {
+            renderer.unmount();
+            if (error) {
+                console.error(`\nUpdate failed: ${error.message}`);
+                process.exit(1);
+            }
+            console.log('\nUpdate complete. Device is rebooting...');
+        } }));
+    await renderer.waitUntilExit();
 }

package/dist/update.ui.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { UploadImage } from './update.js';
+/**
+ * Partition metadata for display
+ */
+export interface UpdateItem {
+    partition: string;
+    version: string;
+    size: number;
+}
+/**
+ * Progress event from upload
+ */
+export interface UpdateProgress {
+    partition: string;
+    phase: 'erase' | 'transfer' | 'complete';
+    current?: number;
+    total?: number;
+}
+interface UpdateUiProps {
+    baseUrl: string;
+    items: UpdateItem[];
+    images: UploadImage[];
+    onComplete: (error?: Error) => void;
+}
+export default function UpdateUi({ baseUrl, items, images, onComplete }: UpdateUiProps): React.JSX.Element;
+export {};

package/dist/update.ui.js

@@ -0,0 +1,119 @@
+import React, { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import useStdoutDimensions from './useStdoutDimensions.js';
+import { uploadFirmware } from './update.js';
+export default function UpdateUi({ baseUrl, items, images, onComplete }) {
+    const [col] = useStdoutDimensions();
+    const [state, setState] = useState(() => initState(items));
+    useEffect(() => {
+        uploadFirmware(baseUrl, images, (progress) => {
+            setState((prev) => updateState(prev, progress));
+        })
+            .then(() => onComplete())
+            .catch((e) => onComplete(e));
+    }, []);
+    const maxNameLen = Math.max(...items.map((i) => i.partition.length));
+    const barWidth = Math.min(col - maxNameLen - 25, 40);
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { bold: true }, "OTA Update")),
+        items.map((item) => {
+            const s = state[item.partition];
+            const percent = s && s.total > 0 ? Math.floor((100 * s.current) / s.total) : 0;
+            const filled = s && s.total > 0 ? Math.floor((barWidth * s.current) / s.total) : 0;
+            const empty = barWidth - filled;
+            return (React.createElement(Box, { key: item.partition },
+                React.createElement(Box, { width: maxNameLen + 1 },
+                    React.createElement(Text, { bold: true }, item.partition.padEnd(maxNameLen))),
+                React.createElement(Box, { marginLeft: 1 },
+                    React.createElement(Text, null, "["),
+                    React.createElement(Text, { color: "green" }, '#'.repeat(filled)),
+                    React.createElement(Text, { color: "gray" }, '-'.repeat(empty)),
+                    React.createElement(Text, null, "]")),
+                React.createElement(Box, { marginLeft: 1, width: 5 },
+                    React.createElement(Text, null,
+                        percent.toString().padStart(3),
+                        "%")),
+                React.createElement(Box, { marginLeft: 1 },
+                    React.createElement(Text, { color: phaseColor(s?.phase) }, phaseText(s?.phase)))));
+        }),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { dimColor: true },
+                formatSize(items.reduce((acc, i) => acc + i.size, 0)),
+                " total"))));
+}
+function initState(items) {
+    return items.reduce((acc, item) => ({
+        ...acc,
+        [item.partition]: {
+            phase: 'pending',
+            current: 0,
+            total: item.size
+        }
+    }), {});
+}
+function updateState(prev, progress) {
+    const current = prev[progress.partition];
+    if (!current)
+        return prev;
+    switch (progress.phase) {
+        case 'erase':
+            return {
+                ...prev,
+                [progress.partition]: { ...current, phase: 'erase' }
+            };
+        case 'transfer':
+            return {
+                ...prev,
+                [progress.partition]: {
+                    ...current,
+                    phase: 'transfer',
+                    current: progress.current ?? current.current
+                }
+            };
+        case 'complete':
+            return {
+                ...prev,
+                [progress.partition]: {
+                    ...current,
+                    phase: 'done',
+                    current: current.total
+                }
+            };
+        default:
+            return prev;
+    }
+}
+function phaseColor(phase) {
+    switch (phase) {
+        case 'erase':
+            return 'yellow';
+        case 'transfer':
+            return 'cyan';
+        case 'done':
+            return 'green';
+        default:
+            return 'gray';
+    }
+}
+function phaseText(phase) {
+    switch (phase) {
+        case 'pending':
+            return 'waiting';
+        case 'erase':
+            return 'erasing';
+        case 'transfer':
+            return 'uploading';
+        case 'done':
+            return 'OK';
+        default:
+            return '';
+    }
+}
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}

package/dist/useStdoutDimensions.d.ts

@@ -0,0 +1 @@
+export default function useStdoutDimensions(): [number, number];

package/dist/useStdoutDimensions.js

@@ -0,0 +1,17 @@
+import { useState, useEffect } from 'react';
+import { useStdout } from 'ink';
+export default function useStdoutDimensions() {
+    const { stdout } = useStdout();
+    const [dimensions, setDimensions] = useState([
+        stdout.columns,
+        stdout.rows
+    ]);
+    useEffect(() => {
+        const handler = () => setDimensions([stdout.columns, stdout.rows]);
+        stdout.on('resize', handler);
+        return () => {
+            stdout.off('resize', handler);
+        };
+    }, [stdout]);
+    return dimensions;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@altronix/cli",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -13,35 +13,35 @@
     "dist"
   ],
   "dependencies": {
-    "@altronix/zdk": "^0.9.0",
+    "@altronix/webtobin": "^0.8.0",
+    "@inquirer/confirm": "^3.2.0",
+    "ajv": "^8.17.1",
+    "cbor2": "^2.2.1",
     "commander": "^10.0.1",
-    "ink": "^4.1.0",
+    "dotenv": "^16.6.1",
+    "ink": "^4.4.1",
     "jsonc-parser": "^3.3.1",
-    "react": "^18.2.0",
-    "rxjs": "^7.8.1",
-    "winston": "^3.13.0",
-    "@altronix/build": "0.13.0"
-  },
-  "optionalDependencies": {
-    "@altronix/device": "0.9.0"
+    "react": "^18.3.1",
+    "rxjs": "^7.8.2",
+    "winston": "^3.19.0"
   },
   "devDependencies": {
     "@sindresorhus/tsconfig": "^3.0.1",
-    "@types/react": "^18.0.32",
+    "@types/react": "^18.3.27",
     "@typescript-eslint/eslint-plugin": "~5.44.0",
     "@typescript-eslint/parser": "~5.44.0",
-    "ava": "^5.2.0",
-    "chalk": "^5.2.0",
+    "ava": "^5.3.1",
+    "chalk": "^5.6.2",
     "eslint": "~8.28.0",
     "eslint-config-prettier": "~8.5.0",
     "eslint-config-xo-react": "^0.27.0",
     "eslint-plugin-jest": "~27.1.7",
-    "eslint-plugin-react": "^7.32.2",
-    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^4.6.2",
     "ink-testing-library": "^3.0.0",
-    "prettier": "^2.8.7",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.0.3",
+    "prettier": "^2.8.8",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
     "xo": "^0.53.1"
   },
   "ava": {