@kvell007/embed-labs-cli 0.1.0-alpha.60 → 0.1.0-alpha.62

package/dist/local-toolchain.js

@@ -184,6 +184,7 @@ export function defaultLocalReleaseRoot() {
 export async function latestLocalToolchain(options = {}) {
     const boardId = options.boardId ?? DEFAULT_BOARD_ID;
     const channelName = options.channel ?? DEFAULT_CHANNEL;
+    const host = localToolchainHostId();
     const { channel, manifests, metadataRoot } = await loadLocalToolchainMetadata(options.metadataRoot, channelName);
     const boardPackageId = boardPackageIdFor(boardId);
     const board = manifests.get(boardPackageId);
@@ -198,20 +199,20 @@ export async function latestLocalToolchain(options = {}) {
         download = await resolveLocalToolchainDownloadPlan({
             boardId: canonicalBoardId,
             channel: channelName,
-            host: hostId(),
+            host,
             toolchain: "llvm"
         });
     }
     catch (error) {
         downloadError = error instanceof Error ? error.message : String(error);
     }
-    if (!download && isNativeWindowsTaishanPiHost(canonicalBoardId, hostId())) {
-        downloadError = taishanPiWindowsRequirementMessage(hostId());
+    if (!download && isNativeWindowsTaishanPiHost(canonicalBoardId, host)) {
+        downloadError = taishanPiWindowsRequirementMessage(host);
     }
     return {
         board_id: canonicalBoardId,
-        channel: channel.channel,
-        host: hostId(),
+        channel: channelName,
+        host,
         version: download?.version ?? board.version,
         metadata_root: metadataRoot,
         packages,
@@ -324,7 +325,7 @@ async function discoverInstalledLocalToolchains(installRoot, current) {
 }
 export async function listLocalToolchainEnvironments(options = {}) {
     const channelName = options.channel ?? DEFAULT_CHANNEL;
-    const host = hostId();
+    const host = localToolchainHostId();
     const installRoot = resolveInstallRoot(options.installRoot);
     const registryPath = localToolchainRegistryPath(installRoot);
     const { channel, manifests, metadataRoot } = await loadLocalToolchainMetadata(options.metadataRoot, channelName);
@@ -412,7 +413,7 @@ export async function listLocalToolchainEnvironments(options = {}) {
             display_name: board.display_name || [board.board, board.variant].filter(Boolean).join(" ") || boardId,
             family: board.family,
             variant: board.variant,
-            channel: channel.channel,
+            channel: channelName,
             host,
             status,
             supported_host: effectiveHostSupport.supported,
@@ -430,9 +431,9 @@ export async function listLocalToolchainEnvironments(options = {}) {
             packages,
             components: download?.components?.map(localToolchainEnvironmentComponent),
             execution,
-            install_command: nativeWindowsTaishanPi ? "embedlabs local wsl status" : `embedlabs local toolchain install --board ${boardId} --mode ${mode}`,
-            update_command: nativeWindowsTaishanPi ? "embedlabs local wsl status" : `embedlabs local toolchain install --board ${boardId} --mode ${mode} --force`,
-            notes: environmentNotes({ boardId, status, downloadError, unsupportedPackages: effectiveHostSupport.unsupportedPackages })
+            install_command: nativeWindowsTaishanPi ? "embedlabs local wsl status" : `embedlabs local toolchain install --board ${boardId}${localToolchainChannelFlag(channelName)} --mode ${mode}`,
+            update_command: nativeWindowsTaishanPi ? "embedlabs local wsl status" : `embedlabs local toolchain install --board ${boardId}${localToolchainChannelFlag(channelName)} --mode ${mode} --force`,
+            notes: environmentNotes({ boardId, host, status, downloadError, unsupportedPackages: effectiveHostSupport.unsupportedPackages })
         });
     }
     const filteredEnvironments = options.installedOnly
@@ -440,7 +441,7 @@ export async function listLocalToolchainEnvironments(options = {}) {
         : environments;
     return {
         host,
-        channel: channel.channel,
+        channel: channelName,
         metadata_source: metadataRoot ? "local_override" : "built_in",
         metadata_root: metadataRoot,
         install_root: installRoot,
@@ -1070,6 +1071,9 @@ function rp2350ArmToolchainDirName() {
 }
 export async function compileTaishanPiSingleFile(options) {
     assertAuthenticated(options.auth);
+    if (platform() === "win32" && normalizeBoardId(options.boardId) === DEFAULT_BOARD_ID) {
+        return await compileTaishanPiSingleFileWindowsWsl(options);
+    }
     const releaseRoot = await resolveLocalReleaseRoot(options.releaseRoot);
     const sourcePath = resolve(options.sourcePath);
     const outputPath = resolve(options.outputPath);
@@ -1095,6 +1099,44 @@ export async function compileTaishanPiSingleFile(options) {
         commands: [buildResult]
     });
 }
+async function compileTaishanPiSingleFileWindowsWsl(options) {
+    const route = taishanPiWindowsExecutionRoute(hostId(), await windowsWslStatus());
+    if (route.actual_host !== "linux-x86_64" || route.status === "wsl_missing" || route.status === "wsl_not_configured" || route.status === "architecture_mismatch") {
+        throw new Error(`${route.reason} Run: embedlabs local wsl status`);
+    }
+    const sourcePath = resolve(options.sourcePath);
+    const outputPath = resolve(options.outputPath);
+    await access(sourcePath, constants.R_OK);
+    await mkdir(dirname(outputPath), { recursive: true });
+    const releaseRoot = options.releaseRoot?.trim()
+        ? normalizeWindowsWslReleaseRoot(options.releaseRoot)
+        : await resolveWindowsWslTaishanPiReleaseRoot();
+    const sourceWslPath = windowsPathToWslPath(sourcePath, "source");
+    const outputWslPath = windowsPathToWslPath(outputPath, "output");
+    const compiler = wslCompilerForSource(releaseRoot, sourcePath);
+    const sysroot = `${trimTrailingSlash(releaseRoot)}/toolchain/host/aarch64-buildroot-linux-gnu/sysroot`;
+    const commandScript = [
+        "set -euo pipefail",
+        `test -x ${sh(compiler)}`,
+        `test -r ${sh(sysroot)}`,
+        `mkdir -p ${sh(posixDirname(outputWslPath))}`,
+        `${sh(compiler)} --sysroot=${sh(sysroot)} -O2 ${sh(sourceWslPath)} -o ${sh(outputWslPath)}`
+    ].join("\n");
+    const buildResult = await runCommand(windowsWslBashCommand(commandScript), homedir());
+    if (buildResult.exit_code !== 0) {
+        throw new Error(`Windows WSL TaishanPi compile failed with exit code ${buildResult.exit_code}: ${buildResult.stderr_tail.join("\n")}`);
+    }
+    return await localCompileResult({
+        boardId: options.boardId,
+        operation: "local.compile.single_file",
+        releaseRoot,
+        accountId: options.accountId,
+        auth: options.auth,
+        sourcePath,
+        artifactPath: outputPath,
+        commands: [buildResult]
+    });
+}
 export async function buildTaishanPiQtSmoke(options) {
     assertAuthenticated(options.auth);
     const releaseRoot = await resolveLocalReleaseRoot(options.releaseRoot);
@@ -1444,8 +1486,8 @@ function environmentNotes(input) {
     if (isRp2350MonitorBoardId(input.boardId)) {
         notes.push("RP2350 Monitor is an optional hardware-control firmware image; the board environment itself is the Pico 2 W or ColorEasyPICO2 C/C++ SDK environment.");
     }
-    if (isNativeWindowsTaishanPiHost(input.boardId, hostId())) {
-        notes.push(taishanPiWindowsRequirementMessage(hostId()));
+    if (isNativeWindowsTaishanPiHost(input.boardId, input.host)) {
+        notes.push(taishanPiWindowsRequirementMessage(input.host));
         notes.push("Check this computer with: embedlabs local wsl status");
     }
     if (input.status === "available") {
@@ -1476,6 +1518,9 @@ function localToolchainInstallModesForDownload(download) {
         ? [...modes].filter((mode) => LOCAL_TOOLCHAIN_INSTALL_MODES.includes(mode))
         : [...LOCAL_TOOLCHAIN_INSTALL_MODES];
 }
+function localToolchainChannelFlag(channelName) {
+    return channelName === DEFAULT_CHANNEL ? "" : ` --channel ${channelName}`;
+}
 function localToolchainEnvironmentComponent(component) {
     return {
         id: component.id,
@@ -1496,6 +1541,23 @@ function hostId() {
     }
     return `${platform()}-${arch()}`;
 }
+const LOCAL_TOOLCHAIN_HOST_IDS = new Set([
+    "darwin-arm64",
+    "linux-x86_64",
+    "linux-arm64",
+    "win32-x64",
+    "win32-arm64"
+]);
+function localToolchainHostId() {
+    const override = process.env.EMBEDLABS_TEST_LOCAL_TOOLCHAIN_HOST?.trim();
+    if (override) {
+        if (!LOCAL_TOOLCHAIN_HOST_IDS.has(override)) {
+            throw new Error(`Unsupported EMBEDLABS_TEST_LOCAL_TOOLCHAIN_HOST value: ${override}`);
+        }
+        return override;
+    }
+    return hostId();
+}
 function isNativeWindowsTaishanPiHost(boardId, host) {
     return normalizeBoardId(boardId) === DEFAULT_BOARD_ID && host.startsWith("win32-");
 }
@@ -2017,6 +2079,84 @@ function compilerForSource(releaseRoot, sourcePath) {
     }
     throw new Error(`Unsupported source extension ${extension || "<none>"}; use .c, .cc, .cpp, or .cxx.`);
 }
+function wslCompilerForSource(releaseRoot, sourcePath) {
+    const extension = extname(sourcePath).toLowerCase();
+    const binDir = `${trimTrailingSlash(releaseRoot)}/toolchain/llvm-cross/bin`;
+    if (extension === ".c") {
+        return `${binDir}/aarch64-linux-gnu-gcc`;
+    }
+    if ([".cc", ".cpp", ".cxx"].includes(extension)) {
+        return `${binDir}/aarch64-linux-gnu-g++`;
+    }
+    throw new Error(`Unsupported source extension ${extension || "<none>"}; use .c, .cc, .cpp, or .cxx.`);
+}
+async function resolveWindowsWslTaishanPiReleaseRoot() {
+    const explicit = process.env.EMBEDLABS_WINDOWS_WSL_TAISHANPI_RELEASE_ROOT?.trim()
+        || process.env.EMBEDLABS_WSL_TAISHANPI_RELEASE_ROOT?.trim();
+    if (explicit) {
+        return normalizeWindowsWslReleaseRoot(explicit);
+    }
+    const script = `
+set -euo pipefail
+REGISTRY="\${EMBEDLABS_WSL_INSTALL_ROOT:-$HOME/.embedlabs}/registry/local-toolchains.json"
+if [ ! -f "$REGISTRY" ]; then
+  echo "Missing WSL TaishanPi registry at $REGISTRY. Run inside WSL first: npx -y embedlabs@latest local toolchain install --board taishanpi-1m-rk3566 --channel windows-test --mode compile" >&2
+  exit 2
+fi
+node - "$REGISTRY" <<'NODE'
+const fs = require("fs");
+const registry = JSON.parse(fs.readFileSync(process.argv[2], "utf8"));
+const env = registry.environments && registry.environments["taishanpi-1m-rk3566"] ? registry.environments["taishanpi-1m-rk3566"] : registry;
+if (!env.release_root) {
+  console.error("WSL TaishanPi registry does not contain release_root. Reinstall with: npx -y embedlabs@latest local toolchain install --board taishanpi-1m-rk3566 --channel windows-test --mode compile");
+  process.exit(2);
+}
+console.log(env.release_root);
+NODE
+`;
+    const result = await runCommand(windowsWslBashCommand(script), homedir());
+    if (result.exit_code !== 0 || result.stdout_tail.length < 1) {
+        throw new Error(`Unable to resolve TaishanPi WSL release root: ${result.stderr_tail.join("\n") || result.stdout_tail.join("\n")}`);
+    }
+    return normalizeWindowsWslReleaseRoot(result.stdout_tail[result.stdout_tail.length - 1]);
+}
+function normalizeWindowsWslReleaseRoot(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw new Error("WSL release root cannot be empty.");
+    }
+    if (/^[A-Za-z]:[\\/]/.test(trimmed)) {
+        return windowsPathToWslPath(resolve(trimmed), "release-root");
+    }
+    if (trimmed.startsWith("/")) {
+        return trimTrailingSlash(trimmed);
+    }
+    throw new Error(`WSL release root must be a Linux absolute path or Windows drive path, got ${value}.`);
+}
+function windowsPathToWslPath(value, label) {
+    const normalized = value.replaceAll("\\", "/");
+    const match = normalized.match(/^([A-Za-z]):\/(.*)$/);
+    if (!match) {
+        throw new Error(`Windows WSL ${label} path must be an absolute drive path, got ${value}.`);
+    }
+    return `/mnt/${match[1].toLowerCase()}/${match[2]}`;
+}
+function windowsWslBashCommand(script) {
+    const command = ["wsl.exe"];
+    const distro = process.env.EMBEDLABS_WINDOWS_WSL_DISTRO?.trim();
+    if (distro) {
+        command.push("-d", distro);
+    }
+    command.push("--", "bash", "-lc", script);
+    return command;
+}
+function posixDirname(value) {
+    const index = value.lastIndexOf("/");
+    return index > 0 ? value.slice(0, index) : "/";
+}
+function sh(value) {
+    return `'${value.replaceAll("'", "'\\''")}'`;
+}
 async function localCompileResult(input) {
     await access(input.artifactPath, constants.R_OK);
     const artifactInfo = await stat(input.artifactPath);