@kvell007/embed-labs-cli 0.1.0-alpha.55 → 0.1.0-alpha.57

package/dist/local-toolchain.d.ts

@@ -116,6 +116,50 @@ export interface LocalToolchainLatestResult {
     download?: LocalToolchainDownloadPlan;
     download_error?: string;
 }
+export interface WindowsWslStatusResult {
+    host: string;
+    platform: string;
+    arch: string;
+    checked_at: string;
+    applicable: boolean;
+    wsl_available: boolean;
+    usable: boolean;
+    distributions: Array<{
+        name: string;
+        state?: string;
+        version?: string;
+        default?: boolean;
+    }>;
+    online_distributions: Array<{
+        name: string;
+        friendly_name?: string;
+        default?: boolean;
+    }>;
+    commands: {
+        status: string;
+        list: string;
+        list_online: string;
+        install_ubuntu: string;
+    };
+    notes: string[];
+}
+export interface WindowsWslInstallOptions {
+    distribution?: string;
+    noLaunch?: boolean;
+    webDownload?: boolean;
+    timeoutMs?: number;
+}
+export interface WindowsWslInstallResult {
+    host: string;
+    platform: string;
+    arch: string;
+    command: string[];
+    exit_code: number;
+    stdout_tail: string[];
+    stderr_tail: string[];
+    status_after: WindowsWslStatusResult;
+    notes: string[];
+}
 export interface LocalToolchainInstallOptions extends LocalToolchainLatestOptions {
     sourceReleaseRoot?: string;
     sourceUrl?: string;
@@ -281,6 +325,8 @@ export declare function latestLocalToolchain(options?: LocalToolchainLatestOptio
 export declare function currentLocalToolchain(installRoot?: string, boardId?: string): Promise<LocalToolchainCurrentResult>;
 export declare function listLocalToolchainEnvironments(options?: LocalToolchainListOptions): Promise<LocalToolchainListResult>;
 export declare function installLocalToolchain(options?: LocalToolchainInstallOptions): Promise<LocalToolchainInstallResult>;
+export declare function windowsWslStatus(): Promise<WindowsWslStatusResult>;
+export declare function windowsWslInstall(options?: WindowsWslInstallOptions): Promise<WindowsWslInstallResult>;
 export declare function uninstallLocalToolchain(options?: LocalToolchainUninstallOptions): Promise<LocalToolchainUninstallResult>;
 export declare function validateLocalToolchain(input?: string | {
     releaseRoot?: string;

package/dist/local-toolchain.js

@@ -205,6 +205,9 @@ export async function latestLocalToolchain(options = {}) {
     catch (error) {
         downloadError = error instanceof Error ? error.message : String(error);
     }
+    if (!download && isNativeWindowsTaishanPiHost(canonicalBoardId, hostId())) {
+        downloadError = taishanPiWindowsRequirementMessage(hostId());
+    }
     return {
         board_id: canonicalBoardId,
         channel: channel.channel,
@@ -357,6 +360,9 @@ export async function listLocalToolchainEnvironments(options = {}) {
         catch (error) {
             downloadError = error instanceof Error ? error.message : String(error);
         }
+        if (!download && isNativeWindowsTaishanPiHost(boardId, host)) {
+            downloadError = taishanPiWindowsRequirementMessage(host);
+        }
         const latestVersion = download?.version ?? board.version;
         const currentForBoard = await currentLocalToolchain(installRoot, boardId);
         const installedCandidate = currentForBoard.installed
@@ -371,9 +377,12 @@ export async function listLocalToolchainEnvironments(options = {}) {
             }
             : undefined;
         const updateAvailable = !!installed?.version && installed.version !== latestVersion;
-        const effectiveHostSupport = download || installed
-            ? { supported: true, unsupportedPackages: [] }
-            : hostSupport;
+        const nativeWindowsTaishanPi = isNativeWindowsTaishanPiHost(boardId, host);
+        const effectiveHostSupport = nativeWindowsTaishanPi
+            ? { supported: false, unsupportedPackages: ["taishanpi-1m-rk3566 native Windows toolchain"] }
+            : download || installed
+                ? { supported: true, unsupportedPackages: [] }
+                : hostSupport;
         const status = !effectiveHostSupport.supported
             ? "unsupported_host"
             : updateAvailable
@@ -410,8 +419,8 @@ export async function listLocalToolchainEnvironments(options = {}) {
             },
             packages,
             components: download?.components?.map(localToolchainEnvironmentComponent),
-            install_command: `embedlabs local toolchain install --board ${boardId} --mode ${mode}`,
-            update_command: `embedlabs local toolchain install --board ${boardId} --mode ${mode} --force`,
+            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 })
         });
     }
@@ -430,6 +439,9 @@ export async function listLocalToolchainEnvironments(options = {}) {
 }
 export async function installLocalToolchain(options = {}) {
     const latest = await latestLocalToolchain(options);
+    if (isNativeWindowsTaishanPiHost(latest.board_id, latest.host)) {
+        throw new Error(taishanPiWindowsRequirementMessage(latest.host));
+    }
     const installRoot = resolveInstallRoot(options.installRoot);
     const releaseRoot = resolve(installRoot, "toolchains", latest.board_id, latest.version);
     const installMode = normalizeLocalToolchainInstallMode(options.mode ?? latest.download?.default_mode);
@@ -511,6 +523,100 @@ export async function installLocalToolchain(options = {}) {
         await rm(tempDir, { recursive: true, force: true });
     }
 }
+export async function windowsWslStatus() {
+    const result = {
+        host: hostId(),
+        platform: platform(),
+        arch: arch(),
+        checked_at: new Date().toISOString(),
+        applicable: platform() === "win32",
+        wsl_available: false,
+        usable: false,
+        distributions: [],
+        online_distributions: [],
+        commands: {
+            status: "wsl.exe --status",
+            list: "wsl.exe -l -v",
+            list_online: "wsl.exe --list --online",
+            install_ubuntu: "wsl.exe --install -d Ubuntu --web-download"
+        },
+        notes: []
+    };
+    if (!result.applicable) {
+        result.notes.push("WSL2 is only required for TaishanPi local development on Windows hosts.");
+        return result;
+    }
+    const whereWsl = await runCommand(["cmd", "/c", "where wsl.exe"], homedir());
+    result.wsl_available = whereWsl.exit_code === 0;
+    if (!result.wsl_available) {
+        result.notes.push("wsl.exe was not found. Enable Windows Subsystem for Linux before installing TaishanPi local tools.");
+        return result;
+    }
+    const list = await runCommand(["wsl.exe", "-l", "-v"], homedir());
+    const normalized = normalizeWindowsCommandText([...list.stdout_tail, ...list.stderr_tail].join("\n"));
+    result.distributions = list.exit_code === 0 ? parseWslDistributionList(normalized) : [];
+    const online = await runCommand(["wsl.exe", "--list", "--online"], homedir());
+    const normalizedOnline = normalizeWindowsCommandText([...online.stdout_tail, ...online.stderr_tail].join("\n"));
+    result.online_distributions = online.exit_code === 0 ? parseWslOnlineDistributionList(normalizedOnline) : [];
+    result.usable = list.exit_code === 0 && result.distributions.length > 0;
+    if (!result.usable) {
+        result.notes.push("No usable WSL2 distribution is configured yet. Install Ubuntu, restart Windows if requested, then run Embed Labs TaishanPi tools inside WSL2.");
+    }
+    else {
+        result.notes.push("Run TaishanPi local compile, Qt, and image tooling inside the listed WSL2 distribution. Native Windows TaishanPi toolchain packages are intentionally not published.");
+    }
+    if (result.host === "win32-arm64") {
+        result.notes.push("This Windows ARM64 host cannot run the current TaishanPi linux-x86_64 WSL2 SDK package. Use Windows x64 with WSL2, or publish a linux-arm64/native Windows TaishanPi package before claiming TaishanPi parity on this host.");
+    }
+    return result;
+}
+export async function windowsWslInstall(options = {}) {
+    const distro = options.distribution?.trim() || "Ubuntu";
+    const command = ["wsl.exe", "--install", "-d", distro];
+    if (options.noLaunch !== false) {
+        command.push("--no-launch");
+    }
+    if (options.webDownload !== false) {
+        command.push("--web-download");
+    }
+    const notes = [];
+    if (platform() !== "win32") {
+        notes.push("WSL installation can only run on Windows hosts.");
+        return {
+            host: hostId(),
+            platform: platform(),
+            arch: arch(),
+            command,
+            exit_code: 1,
+            stdout_tail: [],
+            stderr_tail: [],
+            status_after: await windowsWslStatus(),
+            notes
+        };
+    }
+    const result = await runCommandWithTimeout(command, homedir(), options.timeoutMs ?? 600_000);
+    const statusAfter = await windowsWslStatus();
+    if (result.exit_code === 0) {
+        notes.push("WSL install command completed. If Windows requests a restart, restart before running TaishanPi local tools.");
+    }
+    else {
+        notes.push("WSL install command did not complete successfully. Run the same command in an elevated Windows terminal if the error indicates permissions or reboot requirements.");
+    }
+    if (!statusAfter.usable) {
+        notes.push("WSL2 is still not usable after this command. Complete first-launch setup for the distribution, then rerun embedlabs local wsl status.");
+    }
+    return {
+        host: hostId(),
+        platform: platform(),
+        arch: arch(),
+        command,
+        exit_code: result.exit_code,
+        stdout_tail: result.stdout_tail,
+        stderr_tail: result.stderr_tail,
+        status_after: statusAfter,
+        notes
+    };
+}
 export async function uninstallLocalToolchain(options = {}) {
     if (!options.boardId?.trim()) {
         throw new Error("board_id is required for local toolchain uninstall.");
@@ -1311,6 +1417,10 @@ 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()));
+        notes.push("Check this computer with: embedlabs local wsl status");
+    }
     if (input.status === "available") {
         notes.push("Environment is available but not installed on this computer.");
     }
@@ -1359,6 +1469,74 @@ function hostId() {
     }
     return `${platform()}-${arch()}`;
 }
+function isNativeWindowsTaishanPiHost(boardId, host) {
+    return normalizeBoardId(boardId) === DEFAULT_BOARD_ID && host.startsWith("win32-");
+}
+function taishanPiWindowsRequirementMessage(host) {
+    if (host === "win32-arm64") {
+        return "TaishanPi local compile, Qt, image, and Rockchip tooling is not available on native Windows ARM64. The current Windows route requires Windows x64 with WSL2/Linux x86_64, or a future linux-arm64/native Windows TaishanPi package.";
+    }
+    return "TaishanPi local compile, Qt, image, and Rockchip tooling is supported on Windows through WSL2/Linux x86_64 only; native Windows TaishanPi packages are not published.";
+}
+function normalizeWindowsCommandText(value) {
+    return value.replace(/\0/g, "").replace(/\r/g, "\n");
+}
+function parseWslDistributionList(value) {
+    const distributions = [];
+    const lines = value.split(/\n+/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    for (const rawLine of lines) {
+        if (/^(NAME|Windows Subsystem|Usage|Copyright|\-|用法|选项|命令)/i.test(rawLine)) {
+            continue;
+        }
+        const isDefault = rawLine.startsWith("*");
+        const line = rawLine.replace(/^\*\s*/, "").trim();
+        const parts = line.split(/\s+/).filter(Boolean);
+        if (parts.length === 0 || parts[0].includes(":")) {
+            continue;
+        }
+        const maybeVersion = parts.at(-1);
+        const version = maybeVersion && /^[12]$/.test(maybeVersion) ? maybeVersion : undefined;
+        const state = version && parts.length >= 3 ? parts.at(-2) : parts.length >= 2 ? parts.at(-1) : undefined;
+        distributions.push({
+            name: parts[0],
+            state,
+            version,
+            default: isDefault
+        });
+    }
+    return distributions;
+}
+function parseWslOnlineDistributionList(value) {
+    const distributions = [];
+    const lines = value.split(/\n+/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    let inTable = false;
+    for (const rawLine of lines) {
+        if (/^NAME\s+FRIENDLY NAME/i.test(rawLine)) {
+            inTable = true;
+            continue;
+        }
+        if (!inTable) {
+            continue;
+        }
+        const isDefault = rawLine.startsWith("*");
+        const line = rawLine.replace(/^\*\s*/, "").trim();
+        const parts = line.split(/\s{2,}/).filter(Boolean);
+        const name = parts[0]?.trim();
+        if (!name || name.includes(":")) {
+            continue;
+        }
+        distributions.push({
+            name,
+            friendly_name: parts.slice(1).join(" ").trim() || undefined,
+            default: isDefault
+        });
+    }
+    return distributions;
+}
 function resolveInstallRoot(installRoot) {
     return resolve(installRoot
         || process.env.EMBEDLABS_HOME?.trim()
@@ -1800,6 +1978,68 @@ async function runCommand(command, cwd) {
         });
     });
 }
+async function runCommandWithTimeout(command, cwd, timeoutMs) {
+    return await new Promise((resolve) => {
+        const child = spawn(command[0], command.slice(1), {
+            cwd,
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled) {
+                return;
+            }
+            stderr += `Command timed out after ${timeoutMs} ms.\n`;
+            child.kill("SIGTERM");
+            setTimeout(() => {
+                if (!settled) {
+                    child.kill("SIGKILL");
+                }
+            }, 2_000).unref();
+        }, timeoutMs);
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.on("error", (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            stderr += `${error.message}\n`;
+            resolve({
+                command,
+                cwd,
+                exit_code: 127,
+                stdout_tail: tailLines(stdout),
+                stderr_tail: tailLines(stderr)
+            });
+        });
+        child.on("close", (code) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            const timedOut = stderr.includes(`Command timed out after ${timeoutMs} ms.`);
+            resolve({
+                command,
+                cwd,
+                exit_code: timedOut ? 124 : code ?? 1,
+                stdout_tail: tailLines(stdout),
+                stderr_tail: tailLines(stderr)
+            });
+        });
+    });
+}
 async function fileInfoFor(filePath) {
     const result = await runCommand(["file", filePath], dirname(filePath));
     return result.exit_code === 0 ? result.stdout_tail.join("\n") : undefined;