@kvell007/embed-labs-cli 0.1.0-alpha.30 → 0.1.0-alpha.31

package/dist/local-toolchain.d.ts

@@ -83,6 +83,7 @@ export interface LocalToolchainPackageManifest {
     family?: string;
     board?: string;
     variant?: string;
+    board_id?: string;
     requires?: Array<{
         id: string;
         version: string;
@@ -148,6 +149,7 @@ export interface LocalToolchainCurrentResult {
 }
 export interface LocalToolchainListOptions extends LocalToolchainLatestOptions {
     installRoot?: string;
+    installedOnly?: boolean;
 }
 export interface LocalToolchainEnvironmentRecord {
     board_id: string;
@@ -193,6 +195,7 @@ export interface LocalToolchainEnvironmentComponent {
 export interface LocalToolchainListResult {
     host: string;
     channel: string;
+    metadata_source: "built_in" | "local_override";
     metadata_root?: string;
     install_root: string;
     registry_path: string;
@@ -258,6 +261,7 @@ export declare function installLocalToolchain(options?: LocalToolchainInstallOpt
 export declare function validateLocalToolchain(input?: string | {
     releaseRoot?: string;
     mode?: string;
+    boardId?: string;
 }): Promise<LocalToolchainValidationResult>;
 export declare function compileTaishanPiSingleFile(options: LocalCompileOptions): Promise<LocalCompileResult>;
 export declare function buildTaishanPiQtSmoke(options: LocalQtSmokeBuildOptions): Promise<LocalCompileResult>;

package/dist/local-toolchain.js

@@ -9,8 +9,8 @@ import { pipeline } from "node:stream/promises";
 import { fileURLToPath } from "node:url";
 const DEFAULT_RELEASE_ROOT = "/Volumes/LLVM-TSPI/tspi-rk3566-llvm-release-minimal";
 const DEFAULT_QT_SMOKE_SOURCE = "/Users/kvell/kk-project/DBT-Agent-Project/llvm-build-tspi/qt-smoke";
-const DEFAULT_METADATA_ROOT = "/Users/kvell/kk-project/DBT-Agent-Project/llvm-build-tspi/embedlabs-release";
 const DEFAULT_BOARD_ID = "taishanpi-1m-rk3566";
+const PICO2W_RP2350_BOARD_ID = "pico2w-rp2350-monitor";
 const DEFAULT_CHANNEL = "stable";
 const DEFAULT_DOWNLOAD_BASE_URL = "https://download.embedboard.com";
 const DOWNLOAD_REQUEST_TIMEOUT_MS = 12_000;
@@ -24,7 +24,9 @@ const BUILT_IN_CHANNEL = {
         { id: "embedlabs.tools.runtime.qtquick-live-preview", version: "1.0.31", manifest: "" },
         { id: "embedlabs.tools.runtime.rp2350-monitor", version: "1.0.31", manifest: "" },
         { id: "embedlabs.family.rk356x", version: "1.0.0", manifest: "" },
-        { id: "embedlabs.board.taishanpi.1m-rk3566", version: "1.0.31", manifest: "" }
+        { id: "embedlabs.family.rp2350", version: "1.0.0", manifest: "" },
+        { id: "embedlabs.board.taishanpi.1m-rk3566", version: "1.0.31", manifest: "" },
+        { id: "embedlabs.board.pico2w.rp2350-monitor", version: "1.0.31", manifest: "" }
     ]
 };
 const BUILT_IN_MANIFESTS = {
@@ -80,6 +82,16 @@ const BUILT_IN_MANIFESTS = {
             { id: "embedlabs.tools.common.e2fsprogs", version: "^1.0.0" }
         ]
     },
+    "embedlabs.family.rp2350": {
+        schema: "embedlabs.package.v1",
+        id: "embedlabs.family.rp2350",
+        version: "1.0.0",
+        kind: "family",
+        family: "rp2350",
+        requires: [
+            { id: "embedlabs.tools.runtime.rp2350-monitor", version: "^1.0.31" }
+        ]
+    },
     "embedlabs.board.taishanpi.1m-rk3566": {
         schema: "embedlabs.package.v1",
         id: "embedlabs.board.taishanpi.1m-rk3566",
@@ -97,6 +109,22 @@ const BUILT_IN_MANIFESTS = {
             { id: "embedlabs.tools.runtime.rp2350-monitor", version: "^1.0.31", roles: ["rp2350-monitor"] }
         ],
         build_modes: ["local-llvm"]
+    },
+    "embedlabs.board.pico2w.rp2350-monitor": {
+        schema: "embedlabs.package.v1",
+        id: "embedlabs.board.pico2w.rp2350-monitor",
+        version: "1.0.31",
+        kind: "board",
+        display_name: "Pico 2 W / RP2350 Monitor",
+        family: "rp2350",
+        board: "Pico 2 W",
+        variant: "RP2350 Monitor",
+        board_id: PICO2W_RP2350_BOARD_ID,
+        requires: [
+            { id: "embedlabs.family.rp2350", version: "^1.0.0" },
+            { id: "embedlabs.tools.runtime.rp2350-monitor", version: "^1.0.31", roles: ["hardware-control", "logic-analyzer", "debug-probe"] }
+        ],
+        build_modes: ["local-monitor"]
     }
 };
 const INSTALL_COPY_PATHS = [
@@ -119,7 +147,7 @@ const INSTALL_COPY_PATHS = [
     "support",
     "third_party"
 ];
-const LOCAL_TOOLCHAIN_INSTALL_MODES = ["minimal", "compile", "qt", "full", "images"];
+const LOCAL_TOOLCHAIN_INSTALL_MODES = ["minimal", "runtime", "compile", "qt", "firmware", "full", "images"];
 export function defaultLocalReleaseRoot() {
     return process.env.EMBEDLABS_LOCAL_RELEASE_ROOT?.trim()
         || process.env.EMBEDLABS_RELEASE_ROOT?.trim()
@@ -134,12 +162,13 @@ export async function latestLocalToolchain(options = {}) {
     if (!board) {
         throw new Error(`No local toolchain board package found for ${boardId}.`);
     }
+    const canonicalBoardId = boardIdForPackageManifest(board);
     const packages = resolvePackageRefs(boardPackageId, channel, manifests);
     let download;
     let downloadError;
     try {
         download = await resolveLocalToolchainDownloadPlan({
-            boardId,
+            boardId: canonicalBoardId,
             channel: channelName,
             host: hostId(),
             toolchain: "llvm"
@@ -149,7 +178,7 @@ export async function latestLocalToolchain(options = {}) {
         downloadError = error instanceof Error ? error.message : String(error);
     }
     return {
-        board_id: boardId,
+        board_id: canonicalBoardId,
         channel: channel.channel,
         host: hostId(),
         version: download?.version ?? board.version,
@@ -164,10 +193,34 @@ export async function currentLocalToolchain(installRoot, boardId = DEFAULT_BOARD
     const registryPath = localToolchainRegistryPath(root);
     try {
         const registry = JSON.parse(await readFile(registryPath, "utf8"));
+        const environments = registry.environments;
+        const boardInstall = environments?.[normalizeBoardId(boardId)];
+        if (boardInstall?.release_root) {
+            return {
+                installed: true,
+                board_id: typeof boardInstall.board_id === "string" ? boardInstall.board_id : boardId,
+                version: typeof boardInstall.version === "string" ? boardInstall.version : undefined,
+                mode: typeof boardInstall.mode === "string" ? boardInstall.mode : undefined,
+                release_root: boardInstall.release_root,
+                registry_path: registryPath,
+                install_root: root,
+                channel: typeof boardInstall.channel === "string" ? boardInstall.channel : undefined,
+                packages: Array.isArray(boardInstall.packages) ? boardInstall.packages : undefined
+            };
+        }
         const releaseRoot = typeof registry.release_root === "string" ? registry.release_root : undefined;
+        const registryBoardId = typeof registry.board_id === "string" ? registry.board_id : boardId;
+        if (releaseRoot && normalizeBoardId(registryBoardId) !== normalizeBoardId(boardId)) {
+            return {
+                installed: false,
+                board_id: boardId,
+                registry_path: registryPath,
+                install_root: root
+            };
+        }
         return {
             installed: !!releaseRoot,
-            board_id: typeof registry.board_id === "string" ? registry.board_id : boardId,
+            board_id: registryBoardId,
             version: typeof registry.version === "string" ? registry.version : undefined,
             mode: typeof registry.mode === "string" ? registry.mode : undefined,
             release_root: releaseRoot,
@@ -186,6 +239,58 @@ export async function currentLocalToolchain(installRoot, boardId = DEFAULT_BOARD
         };
     }
 }
+async function discoverInstalledLocalToolchains(installRoot, current) {
+    const installed = new Map();
+    if (current.installed && current.release_root) {
+        installed.set(normalizeBoardId(current.board_id), {
+            board_id: current.board_id,
+            version: current.version,
+            channel: current.channel,
+            mode: current.mode,
+            release_root: current.release_root
+        });
+    }
+    const toolchainsRoot = join(installRoot, "toolchains");
+    let boardEntries;
+    try {
+        boardEntries = await readdir(toolchainsRoot, { withFileTypes: true });
+    }
+    catch {
+        return installed;
+    }
+    for (const boardEntry of boardEntries) {
+        if (!boardEntry.isDirectory()) {
+            continue;
+        }
+        const boardId = normalizeBoardId(boardEntry.name);
+        if (installed.has(boardId)) {
+            continue;
+        }
+        const boardRoot = join(toolchainsRoot, boardEntry.name);
+        let versionEntries;
+        try {
+            versionEntries = await readdir(boardRoot, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        const versions = versionEntries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort(compareVersionLike)
+            .reverse();
+        const version = versions[0];
+        if (!version) {
+            continue;
+        }
+        installed.set(boardId, {
+            board_id: boardId,
+            version,
+            release_root: join(boardRoot, version)
+        });
+    }
+    return installed;
+}
 export async function listLocalToolchainEnvironments(options = {}) {
     const channelName = options.channel ?? DEFAULT_CHANNEL;
     const host = hostId();
@@ -193,6 +298,7 @@ export async function listLocalToolchainEnvironments(options = {}) {
     const registryPath = localToolchainRegistryPath(installRoot);
     const { channel, manifests, metadataRoot } = await loadLocalToolchainMetadata(options.metadataRoot, channelName);
     const current = await currentLocalToolchain(installRoot);
+    const installedByBoard = await discoverInstalledLocalToolchains(installRoot, current);
     const boardManifests = [...manifests.values()]
         .filter((manifest) => manifest.kind === "board")
         .filter((manifest) => {
@@ -224,12 +330,16 @@ export async function listLocalToolchainEnvironments(options = {}) {
             downloadError = error instanceof Error ? error.message : String(error);
         }
         const latestVersion = download?.version ?? board.version;
-        const installed = current.installed && normalizeBoardId(current.board_id) === normalizeBoardId(boardId)
+        const currentForBoard = await currentLocalToolchain(installRoot, boardId);
+        const installedCandidate = currentForBoard.installed
+            ? currentForBoard
+            : installedByBoard.get(normalizeBoardId(boardId));
+        const installed = installedCandidate
             ? {
-                version: current.version,
-                channel: current.channel,
-                mode: current.mode,
-                release_root: current.release_root
+                version: installedCandidate.version,
+                channel: installedCandidate.channel,
+                mode: installedCandidate.mode,
+                release_root: installedCandidate.release_root
             }
             : undefined;
         const updateAvailable = !!installed?.version && installed.version !== latestVersion;
@@ -241,6 +351,7 @@ export async function listLocalToolchainEnvironments(options = {}) {
                     ? "installed"
                     : "available";
         const mode = download?.default_mode ?? "qt";
+        const installModes = localToolchainInstallModesForDownload(download);
         environments.push({
             board_id: boardId,
             package_id: board.id,
@@ -252,7 +363,7 @@ export async function listLocalToolchainEnvironments(options = {}) {
             status,
             supported_host: hostSupport.supported,
             unsupported_packages: hostSupport.unsupportedPackages,
-            install_modes: [...LOCAL_TOOLCHAIN_INSTALL_MODES],
+            install_modes: installModes,
             installed,
             latest: {
                 version: latestVersion,
@@ -269,13 +380,17 @@ export async function listLocalToolchainEnvironments(options = {}) {
             notes: environmentNotes({ status, downloadError, unsupportedPackages: hostSupport.unsupportedPackages })
         });
     }
+    const filteredEnvironments = options.installedOnly
+        ? environments.filter((environment) => !!environment.installed)
+        : environments;
     return {
         host,
         channel: channel.channel,
+        metadata_source: metadataRoot ? "local_override" : "built_in",
         metadata_root: metadataRoot,
         install_root: installRoot,
         registry_path: registryPath,
-        environments
+        environments: filteredEnvironments
     };
 }
 export async function installLocalToolchain(options = {}) {
@@ -284,7 +399,7 @@ export async function installLocalToolchain(options = {}) {
     const releaseRoot = resolve(installRoot, "toolchains", latest.board_id, latest.version);
     const installMode = normalizeLocalToolchainInstallMode(options.mode ?? latest.download?.default_mode);
     if (await pathExists(releaseRoot) && !options.force) {
-        const validation = await validateLocalToolchain({ releaseRoot, mode: installMode });
+        const validation = await validateLocalToolchain({ releaseRoot, mode: installMode, boardId: latest.board_id });
         if (!validation.ok) {
             if (latest.download?.components?.length) {
                 // Component installs can upgrade an existing lower-mode install by overlaying
@@ -336,7 +451,7 @@ export async function installLocalToolchain(options = {}) {
             installedPaths.push(relativePath);
         }
         await writeCurrentRegistry(installRoot, latest, releaseRoot, installMode, sourceRoot.source);
-        const validation = await validateLocalToolchain({ releaseRoot, mode: installMode });
+        const validation = await validateLocalToolchain({ releaseRoot, mode: installMode, boardId: latest.board_id });
         if (!validation.ok) {
             throw new Error(`Installed local toolchain is incomplete: ${validation.missing_paths.join(", ")}`);
         }
@@ -362,8 +477,9 @@ export async function installLocalToolchain(options = {}) {
 export async function validateLocalToolchain(input) {
     const releaseRoot = typeof input === "string" ? input : input?.releaseRoot;
     const mode = normalizeLocalToolchainInstallMode(typeof input === "string" ? undefined : input?.mode);
+    const boardId = normalizeBoardId(typeof input === "string" ? DEFAULT_BOARD_ID : input?.boardId ?? DEFAULT_BOARD_ID);
     const resolvedRoot = await resolveLocalReleaseRoot(releaseRoot);
-    const required = requiredLocalToolchainChecks(mode);
+    const required = requiredLocalToolchainChecks(mode, boardId);
     const checked_paths = [];
     for (const [label, relativePath] of required) {
         const absolutePath = resolve(resolvedRoot, relativePath);
@@ -381,13 +497,13 @@ export async function validateLocalToolchain(input) {
             platform: platform(),
             arch: arch()
         },
-        board_id: DEFAULT_BOARD_ID,
+        board_id: boardId,
         release_root: resolvedRoot,
         checked_paths,
         missing_paths,
         notes: [
             "Local build commands require an Embed Labs auth token so local resource use remains account attributable.",
-            `This validator checks the TaishanPi LLVM local support layout for install mode ${mode}.`
+            `This validator checks the ${boardId} local support layout for install mode ${mode}.`
         ]
     };
 }
@@ -401,7 +517,10 @@ function normalizeLocalToolchainInstallMode(mode) {
     }
     throw new Error(`Unsupported local toolchain install mode ${normalized}; expected ${LOCAL_TOOLCHAIN_INSTALL_MODES.join(", ")}.`);
 }
-function requiredLocalToolchainChecks(mode) {
+function requiredLocalToolchainChecks(mode, boardId) {
+    if (boardId === PICO2W_RP2350_BOARD_ID || boardId === "rp2350" || boardId === "rp2350-monitor") {
+        return requiredRp2350MonitorChecks(mode);
+    }
     const base = [
         ["release root", "."],
         ["Rockchip mkimage", "tools/mac/mkimage"],
@@ -452,6 +571,25 @@ function requiredLocalToolchainChecks(mode) {
     }
     return [...base, ...compile, ...qt, ...images, ...full];
 }
+function requiredRp2350MonitorChecks(mode) {
+    const runtime = [
+        ["release root", "."],
+        ["RP2350 Monitor UI", "toolkit-runtime/rp2350-monitor/ui/index.html"],
+        ["RP2350 Monitor bridge", "toolkit-runtime/rp2350-monitor/ui/bridge/rpmon_bridge.py"],
+        ["RP2350 Monitor CLI", "toolkit-runtime/rp2350-monitor/tools/rpmon_cli.py"],
+        ["RP2350 Monitor logic analyzer", "toolkit-runtime/rp2350-monitor/ui/bin/embed-labs-logic-analyzer"],
+        ["RP2350 Monitor AI operation contract", "toolkit-runtime/rp2350-monitor/ui/docs/ai-operation-contract.md"],
+        ["package metadata", "meta"]
+    ];
+    const firmware = [
+        ["Pico 2 W monitor UF2", "toolkit-runtime/rp2350-monitor/firmware/rp2350_monitor.uf2"],
+        ["Pico 2 W firmware source", "toolkit-runtime/rp2350-monitor/firmware/src/main.cpp"]
+    ];
+    if (mode === "firmware" || mode === "full") {
+        return [...runtime, ...firmware];
+    }
+    return runtime;
+}
 export async function compileTaishanPiSingleFile(options) {
     assertAuthenticated(options.auth);
     const releaseRoot = await resolveLocalReleaseRoot(options.releaseRoot);
@@ -521,15 +659,14 @@ export async function buildTaishanPiQtSmoke(options) {
 }
 async function loadLocalToolchainMetadata(metadataRoot, channelName) {
     const explicitRoot = metadataRoot || process.env.EMBEDLABS_METADATA_ROOT?.trim();
-    const candidateRoot = explicitRoot || (await pathExists(DEFAULT_METADATA_ROOT) ? DEFAULT_METADATA_ROOT : undefined);
-    if (!candidateRoot) {
+    if (!explicitRoot) {
         return {
             channel: BUILT_IN_CHANNEL,
             manifests: new Map(Object.entries(BUILT_IN_MANIFESTS)),
             metadataRoot: undefined
         };
     }
-    const root = resolve(candidateRoot);
+    const root = resolve(explicitRoot);
     const channelPath = join(root, "channels", channelName, "index.json");
     const channel = JSON.parse(await readFile(channelPath, "utf8"));
     if (channel.schema !== "embedlabs.channel.v1") {
@@ -709,6 +846,14 @@ function boardPackageIdFor(boardId) {
     if (boardId === DEFAULT_BOARD_ID || boardId === "taishanpi" || boardId === "taishanpi-1m-rk3566") {
         return "embedlabs.board.taishanpi.1m-rk3566";
     }
+    if (boardId === PICO2W_RP2350_BOARD_ID
+        || boardId === "pico2w"
+        || boardId === "pico-2-w"
+        || boardId === "pico2"
+        || boardId === "rp2350"
+        || boardId === "rp2350-monitor") {
+        return "embedlabs.board.pico2w.rp2350-monitor";
+    }
     if (boardId.startsWith("embedlabs.board.")) {
         return boardId;
     }
@@ -738,6 +883,12 @@ function boardIdForPackageManifest(manifest) {
 function normalizeBoardId(boardId) {
     return boardId.trim().toLowerCase().replaceAll("_", "-");
 }
+function compareVersionLike(left, right) {
+    return left.localeCompare(right, undefined, { numeric: true, sensitivity: "base" });
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
 function packageHostSupport(packages, manifests, host) {
     const unsupportedPackages = [];
     for (const item of packages) {
@@ -767,6 +918,20 @@ function environmentNotes(input) {
     }
     return notes;
 }
+function localToolchainInstallModesForDownload(download) {
+    if (!download?.components?.length) {
+        return [...LOCAL_TOOLCHAIN_INSTALL_MODES];
+    }
+    const modes = new Set();
+    for (const component of download.components) {
+        for (const mode of component.install_modes ?? []) {
+            modes.add(mode);
+        }
+    }
+    return modes.size > 0
+        ? [...modes].filter((mode) => LOCAL_TOOLCHAIN_INSTALL_MODES.includes(mode))
+        : [...LOCAL_TOOLCHAIN_INSTALL_MODES];
+}
 function localToolchainEnvironmentComponent(component) {
     return {
         id: component.id,
@@ -798,7 +963,14 @@ function localToolchainRegistryPath(installRoot) {
 async function writeCurrentRegistry(installRoot, latest, releaseRoot, mode, source) {
     const registryPath = localToolchainRegistryPath(installRoot);
     await mkdir(dirname(registryPath), { recursive: true });
-    await writeFile(registryPath, `${JSON.stringify({
+    let existing = {};
+    try {
+        existing = JSON.parse(await readFile(registryPath, "utf8"));
+    }
+    catch {
+        existing = {};
+    }
+    const entry = {
         installed: true,
         board_id: latest.board_id,
         version: latest.version,
@@ -810,6 +982,19 @@ async function writeCurrentRegistry(installRoot, latest, releaseRoot, mode, sour
         source,
         installed_components: source?.components,
         updated_at: new Date().toISOString()
+    };
+    const environments = isRecord(existing.environments)
+        ? { ...existing.environments }
+        : {};
+    environments[normalizeBoardId(latest.board_id)] = entry;
+    const preserveTopLevel = latest.board_id !== DEFAULT_BOARD_ID
+        && typeof existing.release_root === "string"
+        && normalizeBoardId(String(existing.board_id ?? DEFAULT_BOARD_ID)) === DEFAULT_BOARD_ID;
+    const topLevel = preserveTopLevel ? existing : entry;
+    await writeFile(registryPath, `${JSON.stringify({
+        ...topLevel,
+        environments,
+        updated_at: new Date().toISOString()
     }, null, 2)}\n`, "utf8");
 }
 async function resolveLocalReleaseRoot(releaseRoot) {