@kvell007/embed-labs-cli 0.1.0-alpha.2 → 0.1.0-alpha.4

package/dist/index.js

@@ -1,12 +1,15 @@
 #!/usr/bin/env node
 import { createHash } from "node:crypto";
+import { constants } from "node:fs";
 import { spawn } from "node:child_process";
-import { cp, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { access, cp, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { homedir, tmpdir } from "node:os";
-import { basename, dirname, join, resolve } from "node:path";
+import { basename, delimiter, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { startServer } from "@embed-labs/local-bridge";
+import { composeBootLogoPackage } from "./image-compose.js";
+import { buildTaishanPiQtSmoke, compileTaishanPiSingleFile, currentLocalToolchain, installLocalToolchain, latestLocalToolchain, validateLocalToolchain } from "./local-toolchain.js";
 import { fail, ok } from "@embed-labs/protocol";
 const require = createRequire(import.meta.url);
 const CLI_MODULE_DIR = dirname(fileURLToPath(import.meta.url));
@@ -74,6 +77,16 @@ const BUILD_APPLICATION_STUB_USAGE = "Usage: embed build application stub --work
 const BUILD_APPLICATION_GENERATE_USAGE = "Usage: embed build application generate --workspace <workspace_id> --prompt <request> [--account <account_id>] [--target <source_path>] [--provider stub|openai|bai|cc|claude-code] [--model <model>] [--json]";
 const BUILD_APPLICATION_COMPILE_USAGE = "Usage: embed build application compile --workspace <workspace_id> [--account <account_id>] [--source <source_path>] [--execution-mode docker_worker|server_direct|dry_run] [--compiler auto|cc|gcc|clang|aarch64-linux-gnu-gcc] [--json]";
 const BUILD_IMAGE_GENERATE_USAGE = "Usage: embed build image generate --workspace <workspace_id> --prompt <request> [--account <account_id>] [--image-profile <profile_id>] [--provider stub|openai|bai|cc|claude-code] [--model <model>] [--execution-mode cloud_worker|dry_run] [--worker-pool <pool>] [--json]";
+const BUILD_IMAGE_BOOT_LOGO_USAGE = "Usage: embed build image boot-logo --logo <local_image> [--account <account_id>] [--project <project_id>] [--board taishanpi] [--variant 1M-RK3566] [--kernel-logo <local_image>] [--rotate -90] [--scale 100] [--output <package.json>] [--json]";
+const IMAGE_BOOT_LOGO_COMPOSE_USAGE = "Usage: embed image boot-logo compose --package <boot-logo-package.json> --base-image <boot.img|image.img> --output <image> [--manifest <manifest.json>] [--force] [--json]";
+const BUILD_IMAGE_DTB_USAGE = "Usage: embed build image dtb --dtb <local.dtb|local.dts> [--input-format auto|dtb|dts] [--account <account_id>] [--project <project_id>] [--board taishanpi] [--variant 1M-RK3566] [--output <package.json>] [--json]";
+const IMAGE_DTB_COMPOSE_USAGE = "Usage: embed image dtb compose --package <dtb-package.json> --base-image <boot.img|image.img> --output <image> [--manifest <manifest.json>] [--force] [--json]";
+const LOCAL_TOOLCHAIN_LATEST_USAGE = "Usage: embed local toolchain latest [--board taishanpi-1m-rk3566] [--channel stable] [--metadata-root <path>] [--json]";
+const LOCAL_TOOLCHAIN_CURRENT_USAGE = "Usage: embed local toolchain current [--install-root <path>] [--json]";
+const LOCAL_TOOLCHAIN_INSTALL_USAGE = "Usage: embed local toolchain install [--board taishanpi-1m-rk3566] [--channel stable] [--metadata-root <path>] [--source-url <tar.gz-url>|--source-release-root <path>] [--install-root <path>] [--force] [--json]";
+const LOCAL_TOOLCHAIN_VALIDATE_USAGE = "Usage: embed local toolchain validate [--release-root <path>] [--json]";
+const LOCAL_COMPILE_TAISHANPI_USAGE = "Usage: embed local compile taishanpi --source <main.c|main.cpp> --output <artifact> [--release-root <path>] [--account <account_id>] [--json]";
+const LOCAL_BUILD_QT_SMOKE_USAGE = "Usage: embed local build qt-smoke --build-dir <dir> [--source <qt-smoke-dir>] [--release-root <path>] [--account <account_id>] [--json]";
 const BOARD_REGISTRY_LIST_USAGE = "Usage: embed board registry list [--json]";
 const BOARD_REGISTRY_SHOW_USAGE = "Usage: embed board registry show <template_id> [--json]";
 const BOARD_METHODS_USAGE = "Usage: embed board methods <template_id> [--json]";
@@ -82,7 +95,7 @@ const BOARD_KNOWLEDGE_FILE_USAGE = "Usage: embed board knowledge file <template_
 const MODEL_LIST_USAGE = "Usage: embed model list [--json]";
 const MODEL_DEFAULT_USAGE = "Usage: embed model default [--json]";
 const SERVICE_MODES_USAGE = "Usage: embed service modes [--json]";
-const AGENT_RUN_USAGE = "Usage: embed agent run --prompt <request> [--account <account_id>] [--workspace <workspace_id>] [--provider stub|openai|bai|cc|claude-code] [--model <model>] [--max-tool-calls 4] [--host <ip>] [--ports 22,15301] [--artifact <local_file>|--artifact-id <artifact_id>|--artifact-task <task_id>] [--artifact-output <path>] [--remote-path <path>] [--run] [--approve] [--json]";
+const AGENT_RUN_USAGE = "Usage: embed agent run --prompt <request> [--account <account_id>] [--workspace <workspace_id>] [--provider stub|openai|bai|cc|claude-code] [--model <model>] [--max-tool-calls 6] [--host <ip>] [--ports 22,15301] [--artifact <local_file>|--artifact-id <artifact_id>|--artifact-task <task_id>] [--artifact-output <path>] [--remote-path <path>] [--run] [--approve] [--json]";
 const TOOL_LIST_USAGE = "Usage: embed tool list [--json]";
 const TOOL_CALL_USAGE = "Usage: embed tool call <capability_id> [--input-json '<json>'] [--approve] [--json]";
 const BOARD_DEPLOY_TAISHANPI_USAGE = "Usage: embed deploy taishanpi --host <ip> --artifact <local_file> --approve [--user root] [--remote-path /userdata/embed-labs/apps/app] [--run] [--timeout 30] [--json]";
@@ -475,6 +488,75 @@ async function main(argv) {
                 BILLING_SNAPSHOT_SHOW_USAGE
             ].join("\n")), undefined, 2);
         }
+        if (area === "image") {
+            if ((action === "boot-logo" && parsed.command[2] === "compose") || (action === "compose" && parsed.command[2] === "boot-logo")) {
+                const request = imageBootLogoComposeRequest(parsed, IMAGE_BOOT_LOGO_COMPOSE_USAGE);
+                if (typeof request === "string") {
+                    return output(parsed, fail("invalid_args", request), undefined, 2);
+                }
+                return output(parsed, ok(await composeBootLogoPackage(request)), renderBootLogoComposeResult);
+            }
+            if ((action === "dtb" && parsed.command[2] === "compose") || (action === "compose" && parsed.command[2] === "dtb")) {
+                const request = imageBootLogoComposeRequest(parsed, IMAGE_DTB_COMPOSE_USAGE);
+                if (typeof request === "string") {
+                    return output(parsed, fail("invalid_args", request), undefined, 2);
+                }
+                return output(parsed, ok(await composeBootLogoPackage(request)), renderBootLogoComposeResult);
+            }
+            return output(parsed, fail("invalid_args", [IMAGE_BOOT_LOGO_COMPOSE_USAGE, IMAGE_DTB_COMPOSE_USAGE].join("\n")), undefined, 2);
+        }
+        if (area === "local") {
+            if (action === "toolchain" && parsed.command[2] === "latest") {
+                const request = localToolchainLatestRequest(parsed);
+                if (typeof request === "string") {
+                    return output(parsed, fail("invalid_args", request), undefined, 2);
+                }
+                return output(parsed, ok(await latestLocalToolchain(request)), renderLocalToolchainLatest);
+            }
+            if (action === "toolchain" && parsed.command[2] === "current") {
+                const request = localToolchainCurrentRequest(parsed);
+                if (typeof request === "string") {
+                    return output(parsed, fail("invalid_args", request), undefined, 2);
+                }
+                return output(parsed, ok(await currentLocalToolchain(request.installRoot)), renderLocalToolchainCurrent);
+            }
+            if (action === "toolchain" && parsed.command[2] === "install") {
+                const request = localToolchainInstallRequest(parsed);
+                if (typeof request === "string") {
+                    return output(parsed, fail("invalid_args", request), undefined, 2);
+                }
+                return output(parsed, ok(await installLocalToolchain(request)), renderLocalToolchainInstall);
+            }
+            if (action === "toolchain" && parsed.command[2] === "validate") {
+                const request = localToolchainValidateRequest(parsed);
+                if (typeof request === "string") {
+                    return output(parsed, fail("invalid_args", request), undefined, 2);
+                }
+                return output(parsed, ok(await validateLocalToolchain(request.releaseRoot)), renderLocalToolchainValidation);
+            }
+            if (action === "compile" && parsed.command[2] === "taishanpi") {
+                const request = localCompileTaishanPiRequest(parsed, await authStatus());
+                if (typeof request === "string") {
+                    return output(parsed, fail("invalid_args", request), undefined, 2);
+                }
+                return output(parsed, ok(await compileTaishanPiSingleFile(request)), renderLocalCompileResult);
+            }
+            if (action === "build" && parsed.command[2] === "qt-smoke") {
+                const request = localBuildQtSmokeRequest(parsed, await authStatus());
+                if (typeof request === "string") {
+                    return output(parsed, fail("invalid_args", request), undefined, 2);
+                }
+                return output(parsed, ok(await buildTaishanPiQtSmoke(request)), renderLocalCompileResult);
+            }
+            return output(parsed, fail("invalid_args", [
+                LOCAL_TOOLCHAIN_LATEST_USAGE,
+                LOCAL_TOOLCHAIN_CURRENT_USAGE,
+                LOCAL_TOOLCHAIN_INSTALL_USAGE,
+                LOCAL_TOOLCHAIN_VALIDATE_USAGE,
+                LOCAL_COMPILE_TAISHANPI_USAGE,
+                LOCAL_BUILD_QT_SMOKE_USAGE
+            ].join("\n")), undefined, 2);
+        }
         if (area === "build") {
             if (action === "template") {
                 const templateAction = parsed.command[2];
@@ -620,6 +702,44 @@ async function main(argv) {
                 }
                 return output(parsed, await cloudPost("/v1/build/image-generate", body), renderJob);
             }
+            if (action === "image" && (parsed.command[2] === "boot-logo" || parsed.command[2] === "boot-logo-package")) {
+                const request = await buildImageBootLogoPackageRequest(parsed);
+                if (typeof request === "string") {
+                    return output(parsed, fail("invalid_args", request), undefined, 2);
+                }
+                const created = await cloudPost("/v1/build/image/boot-logo-package", request.body);
+                if (!created.ok || !request.output_path) {
+                    return output(parsed, created, renderJob, created.ok ? 0 : 2);
+                }
+                const packageArtifact = created.data.artifacts?.find((artifact) => artifact.kind === "patch" && artifact.name === "boot-logo-package.json");
+                if (!packageArtifact) {
+                    return output(parsed, fail("artifact_not_found", "Boot-logo package task did not include boot-logo-package.json."), undefined, 2);
+                }
+                const downloaded = await cloudDownloadArtifact(packageArtifact.artifact_id, request.output_path);
+                if (!downloaded.ok) {
+                    return output(parsed, downloaded, renderArtifactDownload, 2);
+                }
+                return output(parsed, ok({ task: created.data, downloaded_artifact: downloaded.data }), renderBootLogoPackageResult);
+            }
+            if (action === "image" && (parsed.command[2] === "dtb" || parsed.command[2] === "dtb-package")) {
+                const request = await buildImageDtbPackageRequest(parsed);
+                if (typeof request === "string") {
+                    return output(parsed, fail("invalid_args", request), undefined, 2);
+                }
+                const created = await cloudPost("/v1/build/image/dtb-package", request.body);
+                if (!created.ok || !request.output_path) {
+                    return output(parsed, created, renderJob, created.ok ? 0 : 2);
+                }
+                const packageArtifact = created.data.artifacts?.find((artifact) => artifact.kind === "patch" && artifact.name === "dtb-package.json");
+                if (!packageArtifact) {
+                    return output(parsed, fail("artifact_not_found", "DTB package task did not include dtb-package.json."), undefined, 2);
+                }
+                const downloaded = await cloudDownloadArtifact(packageArtifact.artifact_id, request.output_path);
+                if (!downloaded.ok) {
+                    return output(parsed, downloaded, renderArtifactDownload, 2);
+                }
+                return output(parsed, ok({ task: created.data, downloaded_artifact: downloaded.data }), renderDtbPackageResult);
+            }
             return output(parsed, fail("invalid_args", [
                 BUILD_TEMPLATE_LIST_USAGE,
                 BUILD_TEMPLATE_SHOW_USAGE,
@@ -636,7 +756,9 @@ async function main(argv) {
                 BUILD_APPLICATION_STUB_USAGE,
                 BUILD_APPLICATION_GENERATE_USAGE,
                 BUILD_APPLICATION_COMPILE_USAGE,
-                BUILD_IMAGE_GENERATE_USAGE
+                BUILD_IMAGE_GENERATE_USAGE,
+                BUILD_IMAGE_BOOT_LOGO_USAGE,
+                BUILD_IMAGE_DTB_USAGE
             ].join("\n")), undefined, 2);
         }
         if (area === "project" && action === "create") {
@@ -1307,16 +1429,16 @@ async function pluginList(parsed) {
         return remoteManifest;
     }
     const effectiveManifest = manifest?.data ?? remoteManifest?.data;
-    const codexPackage = manifest?.data.packages?.find((item) => item.id === "codex-dbt-agent");
-    const opencodePackage = manifest?.data.packages?.find((item) => item.id === "opencode-dbt-agent");
-    const effectiveCodexPackage = effectiveManifest?.packages?.find((item) => item.id === "codex-dbt-agent") ?? codexPackage;
-    const effectiveOpenCodePackage = effectiveManifest?.packages?.find((item) => item.id === "opencode-dbt-agent") ?? opencodePackage;
+    const codexPackage = manifest?.data.packages?.find((item) => item.id === "codex-embed-labs");
+    const opencodePackage = manifest?.data.packages?.find((item) => item.id === "opencode-embed-labs");
+    const effectiveCodexPackage = effectiveManifest?.packages?.find((item) => item.id === "codex-embed-labs") ?? codexPackage;
+    const effectiveOpenCodePackage = effectiveManifest?.packages?.find((item) => item.id === "opencode-embed-labs") ?? opencodePackage;
     const source = releaseDir || remoteManifest ? "release_dir" : "source_checkout";
     return ok({
         plugins: [
             {
                 id: "codex",
-                display_name: "Embed Labs Cloud Codex plugin",
+                display_name: "Embed Labs Codex plugin",
                 source,
                 version: effectiveCodexPackage?.version ?? effectiveManifest?.version ?? await localPluginVersion("codex"),
                 release_file: effectiveCodexPackage?.file,
@@ -1325,7 +1447,7 @@ async function pluginList(parsed) {
             },
             {
                 id: "opencode",
-                display_name: "Embed Labs Cloud OpenCode plugin",
+                display_name: "Embed Labs OpenCode plugin",
                 source,
                 version: effectiveOpenCodePackage?.version ?? effectiveManifest?.version ?? await localPluginVersion("opencode"),
                 release_file: effectiveOpenCodePackage?.file,
@@ -1401,7 +1523,7 @@ async function installCodexPlugin(parsed, context) {
         return source;
     }
     const targetRoot = codexPluginTargetRoot(parsed, context.installingAll);
-    const targetPath = join(targetRoot, "dbt-agent");
+    const targetPath = join(targetRoot, "embed-labs");
     if (await pathExists(targetPath) && !booleanFlag(parsed, "force")) {
         return fail("plugin_already_installed", `Codex plugin already exists at ${targetPath}.`, {
             remediation: "Pass --force to replace it, or pass --codex-target/--target to install into a different directory."
@@ -1410,12 +1532,17 @@ async function installCodexPlugin(parsed, context) {
     await rm(targetPath, { recursive: true, force: true });
     await mkdir(targetRoot, { recursive: true });
     await cp(source.data.sourcePath, targetPath, { recursive: true });
+    const mcpRegistration = await maybeRegisterCodexMcp(parsed, targetRoot, targetPath);
     return ok({
         id: "codex",
         target_path: targetPath,
         source: source.data.sourceLabel,
         version: source.data.version,
-        command_hint: "Restart Codex or reload plugins after installing."
+        command_hint: mcpRegistration.registered
+            ? "Codex MCP was registered. Start a new Codex session to reload tools."
+            : mcpRegistration.hint,
+        mcp_registered: mcpRegistration.registered,
+        mcp_warning: mcpRegistration.warning
     });
 }
 async function installOpenCodePlugin(parsed, context) {
@@ -1451,20 +1578,22 @@ async function installOpenCodePlugin(parsed, context) {
         });
     }
     await ensureOpenCodeInstallPackageJson(targetRoot);
-    await writeFile(wrapperPath, `export { default, DevelopmentBoardToolchainPlugin } from "dbt-agent";\n`, "utf8");
+    await writeFile(wrapperPath, `export { default, DevelopmentBoardToolchainPlugin } from "embed-labs";\n`, "utf8");
+    const duplicateWarning = await openCodeDuplicatePluginWarning(targetRoot);
     return ok({
         id: "opencode",
         target_path: targetRoot,
         source: source.data.sourceLabel,
         version: source.data.version,
-        command_hint: "Start OpenCode from the project containing this .opencode directory."
+        command_hint: "Start OpenCode from the project containing this .opencode directory.",
+        warning: duplicateWarning
     });
 }
 async function resolveCodexPluginSource(context) {
     if (context.releaseDir) {
-        const item = context.manifest?.packages?.find((entry) => entry.id === "codex-dbt-agent");
+        const item = context.manifest?.packages?.find((entry) => entry.id === "codex-embed-labs");
         if (!item?.file) {
-            return fail("plugin_release_not_found", `Release manifest in ${context.releaseDir} does not include codex-dbt-agent.`);
+            return fail("plugin_release_not_found", `Release manifest in ${context.releaseDir} does not include codex-embed-labs.`);
         }
         const tarball = resolve(context.releaseDir, item.file);
         const verified = await verifyReleasePackage(tarball, item);
@@ -1479,13 +1608,13 @@ async function resolveCodexPluginSource(context) {
                 details: { exit_code: tarResult.code, stderr_tail: tarResult.stderr.split("\n").slice(-20) }
             });
         }
-        const sourcePath = join(extractDir, "codex_plugin", "plugins", "dbt-agent");
+        const sourcePath = join(extractDir, "codex_plugin", "plugins", "embed-labs");
         if (!await pathExists(join(sourcePath, ".codex-plugin", "plugin.json"))) {
-            return fail("plugin_release_invalid", `Codex plugin release ${tarball} did not contain plugins/dbt-agent/.codex-plugin/plugin.json.`);
+            return fail("plugin_release_invalid", `Codex plugin release ${tarball} did not contain plugins/embed-labs/.codex-plugin/plugin.json.`);
         }
         return ok({ sourcePath, sourceLabel: tarball, version: item.version ?? context.manifest?.version });
     }
-    const sourcePath = sourceCheckoutPath("platform_plugins", "codex_plugin", "plugins", "dbt-agent");
+    const sourcePath = sourceCheckoutPath("platform_plugins", "codex_plugin", "plugins", "embed-labs");
     if (!await pathExists(join(sourcePath, ".codex-plugin", "plugin.json"))) {
         return fail("plugin_source_not_found", "Could not find Codex plugin source in this checkout.", {
             remediation: "Run from the Embed-Labs-Cloud repo root or pass --release-dir pointing to a plugin release directory."
@@ -1495,9 +1624,9 @@ async function resolveCodexPluginSource(context) {
 }
 async function resolveOpenCodePluginSource(context) {
     if (context.releaseDir) {
-        const item = context.manifest?.packages?.find((entry) => entry.id === "opencode-dbt-agent");
+        const item = context.manifest?.packages?.find((entry) => entry.id === "opencode-embed-labs");
         if (!item?.file) {
-            return fail("plugin_release_not_found", `Release manifest in ${context.releaseDir} does not include opencode-dbt-agent.`);
+            return fail("plugin_release_not_found", `Release manifest in ${context.releaseDir} does not include opencode-embed-labs.`);
         }
         const tarball = resolve(context.releaseDir, item.file);
         const verified = await verifyReleasePackage(tarball, item);
@@ -1512,7 +1641,32 @@ async function resolveOpenCodePluginSource(context) {
             remediation: "Run from the Embed-Labs-Cloud repo root or pass --release-dir pointing to a plugin release directory."
         });
     }
-    return ok({ packagePath, sourceLabel: packagePath, version: await localPluginVersion("opencode") });
+    const packed = await runLocalProcess("npm", ["pack", packagePath, "--pack-destination", context.tempDir, "--json"]);
+    if (packed.code !== 0) {
+        return fail("opencode_plugin_pack_failed", "npm pack failed while preparing the OpenCode plugin source package.", {
+            details: {
+                exit_code: packed.code,
+                stdout_tail: packed.stdout.split("\n").slice(-20),
+                stderr_tail: packed.stderr.split("\n").slice(-20)
+            }
+        });
+    }
+    let tarballName = "";
+    try {
+        const parsed = JSON.parse(packed.stdout);
+        tarballName = basename(parsed[0]?.filename || "");
+    }
+    catch {
+        tarballName = "";
+    }
+    if (!tarballName) {
+        return fail("opencode_plugin_pack_failed", "npm pack did not report an OpenCode plugin tarball filename.");
+    }
+    const tarballPath = join(context.tempDir, tarballName);
+    if (!await pathExists(tarballPath)) {
+        return fail("opencode_plugin_pack_failed", `npm pack reported ${tarballName}, but the tarball was not found.`);
+    }
+    return ok({ packagePath: tarballPath, sourceLabel: `${packagePath} -> ${tarballPath}`, version: await localPluginVersion("opencode") });
 }
 async function fetchRemotePluginManifest(parsed) {
     const manifestUrl = `${pluginReleaseBaseUrl(parsed)}/manifest.json`;
@@ -1648,12 +1802,203 @@ function openCodePluginTargetRoot(parsed, installingAll) {
 function defaultCodexPluginRoot() {
     return join(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex"), "plugins");
 }
+async function maybeRegisterCodexMcp(parsed, targetRoot, targetPath) {
+    const explicitTarget = Boolean(stringFlag(parsed, "target") || stringFlag(parsed, "codex-target"));
+    if (explicitTarget && process.env.EMBED_CODEX_MCP_REGISTER !== "1") {
+        return {
+            registered: false,
+            hint: `Installed into a custom target. Register manually with: codex mcp add embed-labs -- node ${join(targetPath, "scripts", "embed-labs-mcp-bridge.mjs")}`
+        };
+    }
+    const bridgePath = join(targetPath, "scripts", "embed-labs-mcp-bridge.mjs");
+    if (!await pathExists(bridgePath)) {
+        return {
+            registered: false,
+            hint: "Restart Codex or reload plugins after installing.",
+            warning: `Codex MCP bridge was not found at ${bridgePath}.`
+        };
+    }
+    const codexBin = await resolveExecutableOnPath("codex");
+    if (!codexBin) {
+        return {
+            registered: false,
+            hint: `Codex CLI was not found on PATH. Register manually with: codex mcp add embed-labs -- node ${bridgePath}`
+        };
+    }
+    const embedCliBin = process.env.EMBED_CLI_BIN?.trim() || await resolveExecutableOnPath("embedlabs") || await resolveExecutableOnPath("embed") || "";
+    const authFile = resolve(process.env.EMBED_AUTH_FILE?.trim() || DEFAULT_AUTH_FILE);
+    const cloudUrl = pluginMcpCloudApiUrl(parsed);
+    const existing = await runLocalProcess(codexBin, ["mcp", "get", "embed-labs", "--json"]);
+    if (existing.code === 0 && codexMcpAlreadyRegistered(existing.stdout, bridgePath, cloudUrl, authFile, embedCliBin)) {
+        const warning = await upsertCodexMcpRuntimeConfig(bridgePath);
+        if (warning) {
+            return { registered: true, warning };
+        }
+        return { registered: true };
+    }
+    await runLocalProcess(codexBin, ["mcp", "remove", "embed-labs"]);
+    const args = [
+        "mcp",
+        "add",
+        "embed-labs",
+        "--env",
+        `EMBED_CLOUD_API_URL=${cloudUrl}`,
+        "--env",
+        `EMBED_AUTH_FILE=${authFile}`
+    ];
+    if (embedCliBin) {
+        args.push("--env", `EMBED_CLI_BIN=${embedCliBin}`);
+    }
+    args.push("--", process.execPath, bridgePath);
+    const addResult = await runLocalProcess(codexBin, args);
+    if (addResult.code !== 0) {
+        return {
+            registered: false,
+            hint: `Codex plugin installed. Register manually with: codex mcp add embed-labs -- ${process.execPath} ${bridgePath}`,
+            warning: `codex mcp add failed: ${addResult.stderr.trim() || addResult.stdout.trim() || `exit ${addResult.code}`}`
+        };
+    }
+    const warning = await upsertCodexMcpRuntimeConfig(bridgePath);
+    return warning ? { registered: true, warning } : { registered: true };
+}
+function codexMcpAlreadyRegistered(stdout, bridgePath, cloudUrl, authFile, embedCliBin) {
+    try {
+        const parsed = JSON.parse(stdout);
+        const transport = parsed.transport;
+        if (transport?.type !== "stdio" || transport.command !== process.execPath)
+            return false;
+        if (!transport.args?.includes(bridgePath))
+            return false;
+        const env = transport.env || {};
+        if (env.EMBED_CLOUD_API_URL !== cloudUrl)
+            return false;
+        if (env.EMBED_AUTH_FILE !== authFile)
+            return false;
+        if (embedCliBin && env.EMBED_CLI_BIN !== embedCliBin)
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function upsertCodexMcpRuntimeConfig(bridgePath) {
+    const configPath = join(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex"), "config.toml");
+    try {
+        await mkdir(dirname(configPath), { recursive: true });
+        let text = "";
+        try {
+            text = await readFile(configPath, "utf8");
+        }
+        catch {
+            text = "";
+        }
+        const updated = upsertTomlTableKeys(text, "mcp_servers.embed-labs", {
+            command: tomlString(process.execPath),
+            args: `[${tomlString(bridgePath)}]`,
+            startup_timeout_sec: "120"
+        });
+        if (updated !== text) {
+            await writeFile(configPath, updated, "utf8");
+        }
+        return undefined;
+    }
+    catch (error) {
+        return `Codex MCP was registered, but ${configPath} could not be updated with startup_timeout_sec: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+function upsertTomlTableKeys(text, tableName, values) {
+    const normalized = text.endsWith("\n") || text.length === 0 ? text : `${text}\n`;
+    const header = `[${tableName}]`;
+    const tablePattern = new RegExp(`(^|\\n)(\\[${escapeRegExp(tableName)}\\]\\n)([\\s\\S]*?)(?=\\n\\[|$)`);
+    const match = tablePattern.exec(normalized);
+    const bodyWithValues = (body) => {
+        let updated = body;
+        for (const [key, value] of Object.entries(values)) {
+            const keyPattern = new RegExp(`^${escapeRegExp(key)}\\s*=.*$`, "m");
+            if (keyPattern.test(updated)) {
+                updated = updated.replace(keyPattern, `${key} = ${value}`);
+            }
+            else {
+                updated = `${updated.replace(/\s*$/, "\n")}${key} = ${value}\n`;
+            }
+        }
+        return updated;
+    };
+    if (!match) {
+        const prefix = normalized.length > 0 && !normalized.endsWith("\n\n") ? `${normalized}\n` : normalized;
+        return `${prefix}${header}\n${bodyWithValues("")}`;
+    }
+    return `${normalized.slice(0, match.index)}${match[1]}${match[2]}${bodyWithValues(match[3])}${normalized.slice(match.index + match[0].length)}`;
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function pluginMcpCloudApiUrl(parsed) {
+    const explicit = process.env.EMBED_CLOUD_API_URL?.trim();
+    if (explicit)
+        return explicit.replace(/\/+$/, "");
+    const releaseUrl = stringFlag(parsed, "release-url") || DEFAULT_PLUGIN_RELEASE_URL;
+    try {
+        return new URL(releaseUrl).origin;
+    }
+    catch {
+        return DEFAULT_CLOUD_API_URL.replace(/\/+$/, "");
+    }
+}
+async function resolveExecutableOnPath(name) {
+    if (name.includes("/")) {
+        try {
+            await access(name, constants.X_OK);
+            return name;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const pathEntries = (process.env.PATH || "").split(delimiter).filter(Boolean);
+    for (const entry of pathEntries) {
+        const candidate = join(entry, name);
+        try {
+            await access(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // Keep searching PATH.
+        }
+    }
+    return undefined;
+}
 function defaultOpenCodeRoot() {
     return join(process.cwd(), ".opencode");
 }
+async function openCodeDuplicatePluginWarning(targetRoot) {
+    const globalRoot = join(homedir(), ".config", "opencode");
+    if (resolve(targetRoot) === resolve(globalRoot))
+        return undefined;
+    const configPath = join(globalRoot, "opencode.json");
+    try {
+        const parsed = JSON.parse(await readFile(configPath, "utf8"));
+        const configuredPlugins = Array.isArray(parsed.plugin)
+            ? parsed.plugin
+            : Array.isArray(parsed.plugins)
+                ? parsed.plugins
+                : [];
+        if (configuredPlugins.some((item) => item === "embed-labs")) {
+            return "Global OpenCode config already enables embed-labs; OpenCode may load both the global plugin and this project .opencode plugin. Disable one entry if duplicate DBT tools appear.";
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
 async function localPluginVersion(kind) {
     const filePath = kind === "codex"
-        ? sourceCheckoutPath("platform_plugins", "codex_plugin", "plugins", "dbt-agent", ".codex-plugin", "plugin.json")
+        ? sourceCheckoutPath("platform_plugins", "codex_plugin", "plugins", "embed-labs", ".codex-plugin", "plugin.json")
         : sourceCheckoutPath("platform_plugins", "opencode_plugin", "package.json");
     try {
         const parsed = JSON.parse(await readFile(filePath, "utf8"));
@@ -1664,7 +2009,7 @@ async function localPluginVersion(kind) {
     }
 }
 async function localPluginSourcesAvailable() {
-    return await pathExists(sourceCheckoutPath("platform_plugins", "codex_plugin", "plugins", "dbt-agent", ".codex-plugin", "plugin.json"))
+    return await pathExists(sourceCheckoutPath("platform_plugins", "codex_plugin", "plugins", "embed-labs", ".codex-plugin", "plugin.json"))
         && await pathExists(sourceCheckoutPath("platform_plugins", "opencode_plugin", "package.json"));
 }
 function sourceCheckoutPath(...segments) {
@@ -2104,6 +2449,36 @@ function agentRunToolInputs(parsed) {
             ports: ports.values.length > 0 ? ports.values : [22, 15301],
             timeout_ms: timeout.value !== undefined ? timeout.value * 1000 : undefined
         });
+        inputs["wifi.scan"] = compactBody({
+            host: host.value,
+            user: user.value,
+            timeout_seconds: timeout.value
+        });
+        inputs["bluetooth.scan"] = compactBody({
+            host: host.value,
+            user: user.value,
+            timeout_seconds: timeout.value
+        });
+        inputs["chip.cpu.frequency"] = compactBody({
+            host: host.value,
+            user: user.value,
+            timeout_seconds: timeout.value
+        });
+        inputs["chip.temperature"] = compactBody({
+            host: host.value,
+            user: user.value,
+            timeout_seconds: timeout.value
+        });
+        inputs["qml.runtime.status"] = compactBody({
+            host: host.value,
+            user: user.value,
+            timeout_seconds: timeout.value
+        });
+        inputs["qml.runtime.start"] = compactBody({
+            host: host.value,
+            user: user.value,
+            timeout_seconds: timeout.value
+        });
     }
     if (artifact.value || remotePath.value || user.value || booleanFlag(parsed, "run")) {
         inputs["taishanpi.deploy"] = compactBody({
@@ -2784,6 +3159,231 @@ function buildImageGenerateBody(parsed) {
         worker_pool: workerPool.value
     });
 }
+async function buildImageBootLogoPackageRequest(parsed) {
+    const unknownFlag = firstUnknownFlag(parsed, [
+        "json",
+        "account",
+        "project",
+        "project-id",
+        "board",
+        "board-id",
+        "variant",
+        "variant-id",
+        "logo",
+        "logo-path",
+        "kernel-logo",
+        "kernel-logo-path",
+        "rotate",
+        "scale",
+        "output"
+    ]);
+    if (unknownFlag) {
+        return `Unknown flag --${unknownFlag}. ${BUILD_IMAGE_BOOT_LOGO_USAGE}`;
+    }
+    const extra = parsed.command.slice(3);
+    if (extra.length > 0) {
+        return `Unexpected argument: ${extra[0]}. ${BUILD_IMAGE_BOOT_LOGO_USAGE}`;
+    }
+    const logo = optionalTrimmedStringAliasFlag(parsed, ["logo", "logo-path"], "logo or logo-path");
+    if (logo.error) {
+        return logo.error;
+    }
+    if (!logo.value) {
+        return BUILD_IMAGE_BOOT_LOGO_USAGE;
+    }
+    const logoPath = resolve(logo.value);
+    const logoRead = await readLocalFileForUpload(logoPath, "logo");
+    if (typeof logoRead === "string") {
+        return logoRead;
+    }
+    const kernelLogo = optionalTrimmedStringAliasFlag(parsed, ["kernel-logo", "kernel-logo-path"], "kernel-logo or kernel-logo-path");
+    if (kernelLogo.error) {
+        return kernelLogo.error;
+    }
+    let kernelLogoRead;
+    if (kernelLogo.value) {
+        const kernelLogoPath = resolve(kernelLogo.value);
+        const read = await readLocalFileForUpload(kernelLogoPath, "kernel-logo");
+        if (typeof read === "string") {
+            return read;
+        }
+        kernelLogoRead = read;
+    }
+    const account = optionalTrimmedStringFlag(parsed, "account");
+    if (account.error) {
+        return account.error;
+    }
+    const project = optionalTrimmedStringAliasFlag(parsed, ["project", "project-id"], "project or project-id");
+    if (project.error) {
+        return project.error;
+    }
+    const board = optionalTrimmedStringAliasFlag(parsed, ["board", "board-id"], "board or board-id");
+    if (board.error) {
+        return board.error;
+    }
+    const variant = optionalTrimmedStringAliasFlag(parsed, ["variant", "variant-id"], "variant or variant-id");
+    if (variant.error) {
+        return variant.error;
+    }
+    const rotate = optionalTrimmedStringFlag(parsed, "rotate");
+    if (rotate.error) {
+        return rotate.error;
+    }
+    const scale = optionalTrimmedStringFlag(parsed, "scale");
+    if (scale.error) {
+        return scale.error;
+    }
+    const outputPath = optionalTrimmedStringFlag(parsed, "output");
+    if (outputPath.error) {
+        return outputPath.error;
+    }
+    const body = {
+        account_id: account.value,
+        project_id: project.value,
+        board_id: board.value ?? "taishanpi",
+        variant_id: variant.value,
+        logo_name: basename(logoRead.path),
+        logo_content_base64: logoRead.bytes.toString("base64"),
+        logo_sha256: logoRead.sha256,
+        kernel_logo_name: kernelLogoRead ? basename(kernelLogoRead.path) : undefined,
+        kernel_logo_content_base64: kernelLogoRead?.bytes.toString("base64"),
+        kernel_logo_sha256: kernelLogoRead?.sha256,
+        rotate: rotate.value,
+        scale: scale.value
+    };
+    return {
+        body,
+        output_path: outputPath.value ? resolve(outputPath.value) : undefined
+    };
+}
+async function buildImageDtbPackageRequest(parsed) {
+    const unknownFlag = firstUnknownFlag(parsed, [
+        "json",
+        "account",
+        "project",
+        "project-id",
+        "board",
+        "board-id",
+        "variant",
+        "variant-id",
+        "dtb",
+        "dtb-path",
+        "dts",
+        "dts-path",
+        "input-format",
+        "output"
+    ]);
+    if (unknownFlag) {
+        return `Unknown flag --${unknownFlag}. ${BUILD_IMAGE_DTB_USAGE}`;
+    }
+    const extra = parsed.command.slice(3);
+    if (extra.length > 0) {
+        return `Unexpected argument: ${extra[0]}. ${BUILD_IMAGE_DTB_USAGE}`;
+    }
+    const dtb = optionalTrimmedStringAliasFlag(parsed, ["dtb", "dtb-path", "dts", "dts-path"], "dtb or dts path");
+    if (dtb.error) {
+        return dtb.error;
+    }
+    if (!dtb.value) {
+        return BUILD_IMAGE_DTB_USAGE;
+    }
+    const dtbPath = resolve(dtb.value);
+    const dtbRead = await readLocalFileForUpload(dtbPath, "dtb");
+    if (typeof dtbRead === "string") {
+        return dtbRead;
+    }
+    const account = optionalTrimmedStringFlag(parsed, "account");
+    if (account.error) {
+        return account.error;
+    }
+    const project = optionalTrimmedStringAliasFlag(parsed, ["project", "project-id"], "project or project-id");
+    if (project.error) {
+        return project.error;
+    }
+    const board = optionalTrimmedStringAliasFlag(parsed, ["board", "board-id"], "board or board-id");
+    if (board.error) {
+        return board.error;
+    }
+    const variant = optionalTrimmedStringAliasFlag(parsed, ["variant", "variant-id"], "variant or variant-id");
+    if (variant.error) {
+        return variant.error;
+    }
+    const inputFormat = optionalTrimmedStringFlag(parsed, "input-format");
+    if (inputFormat.error) {
+        return inputFormat.error;
+    }
+    const outputPath = optionalTrimmedStringFlag(parsed, "output");
+    if (outputPath.error) {
+        return outputPath.error;
+    }
+    const body = {
+        account_id: account.value,
+        project_id: project.value,
+        board_id: board.value ?? "taishanpi",
+        variant_id: variant.value,
+        dtb_name: basename(dtbRead.path),
+        dtb_content_base64: dtbRead.bytes.toString("base64"),
+        dtb_sha256: dtbRead.sha256,
+        input_format: inputFormat.value
+    };
+    return {
+        body,
+        output_path: outputPath.value ? resolve(outputPath.value) : undefined
+    };
+}
+function imageBootLogoComposeRequest(parsed, usage) {
+    const unknownFlag = firstUnknownFlag(parsed, [
+        "json",
+        "package",
+        "package-path",
+        "base-image",
+        "base-image-path",
+        "output",
+        "output-image",
+        "manifest",
+        "manifest-path",
+        "force"
+    ]);
+    if (unknownFlag) {
+        return `Unknown flag --${unknownFlag}. ${usage}`;
+    }
+    const extra = parsed.command.slice(3);
+    if (extra.length > 0) {
+        return `Unexpected argument: ${extra[0]}. ${usage}`;
+    }
+    const packagePath = optionalTrimmedStringAliasFlag(parsed, ["package", "package-path"], "package or package-path");
+    if (packagePath.error) {
+        return packagePath.error;
+    }
+    if (!packagePath.value) {
+        return usage;
+    }
+    const baseImage = optionalTrimmedStringAliasFlag(parsed, ["base-image", "base-image-path"], "base-image or base-image-path");
+    if (baseImage.error) {
+        return baseImage.error;
+    }
+    if (!baseImage.value) {
+        return usage;
+    }
+    const outputImage = optionalTrimmedStringAliasFlag(parsed, ["output", "output-image"], "output or output-image");
+    if (outputImage.error) {
+        return outputImage.error;
+    }
+    if (!outputImage.value) {
+        return usage;
+    }
+    const manifest = optionalTrimmedStringAliasFlag(parsed, ["manifest", "manifest-path"], "manifest or manifest-path");
+    if (manifest.error) {
+        return manifest.error;
+    }
+    return {
+        packagePath: resolve(packagePath.value),
+        baseImagePath: resolve(baseImage.value),
+        outputImagePath: resolve(outputImage.value),
+        manifestPath: manifest.value ? resolve(manifest.value) : undefined,
+        force: booleanFlag(parsed, "force")
+    };
+}
 function boardKnowledgeFileRequest(parsed) {
     const unknownFlag = firstUnknownFlag(parsed, ["json", "source", "path", "output"]);
     if (unknownFlag) {
@@ -3451,6 +4051,181 @@ function billingSnapshotListRequest(parsed) {
     }
     return { path: `/v1/accounts/${encodeURIComponent(accountResult.value)}/billing/snapshots` };
 }
+function localToolchainLatestRequest(parsed) {
+    const unknownFlag = firstUnknownFlag(parsed, ["json", "board", "board-id", "channel", "metadata-root"]);
+    if (unknownFlag) {
+        return `Unknown flag --${unknownFlag}. ${LOCAL_TOOLCHAIN_LATEST_USAGE}`;
+    }
+    const extra = parsed.command.slice(3);
+    if (extra.length > 0) {
+        return `Unexpected argument: ${extra[0]}. ${LOCAL_TOOLCHAIN_LATEST_USAGE}`;
+    }
+    const board = optionalTrimmedStringAliasFlag(parsed, ["board", "board-id"], "board or board-id");
+    if (board.error)
+        return board.error;
+    const channel = optionalTrimmedStringFlag(parsed, "channel");
+    if (channel.error)
+        return channel.error;
+    const metadataRoot = optionalTrimmedStringFlag(parsed, "metadata-root");
+    if (metadataRoot.error)
+        return metadataRoot.error;
+    return { boardId: board.value, channel: channel.value, metadataRoot: metadataRoot.value };
+}
+function localToolchainCurrentRequest(parsed) {
+    const unknownFlag = firstUnknownFlag(parsed, ["json", "install-root"]);
+    if (unknownFlag) {
+        return `Unknown flag --${unknownFlag}. ${LOCAL_TOOLCHAIN_CURRENT_USAGE}`;
+    }
+    const extra = parsed.command.slice(3);
+    if (extra.length > 0) {
+        return `Unexpected argument: ${extra[0]}. ${LOCAL_TOOLCHAIN_CURRENT_USAGE}`;
+    }
+    const installRoot = optionalTrimmedStringFlag(parsed, "install-root");
+    if (installRoot.error)
+        return installRoot.error;
+    return { installRoot: installRoot.value };
+}
+function localToolchainInstallRequest(parsed) {
+    const unknownFlag = firstUnknownFlag(parsed, ["json", "board", "board-id", "channel", "metadata-root", "source-url", "source-release-root", "install-root", "force"]);
+    if (unknownFlag) {
+        return `Unknown flag --${unknownFlag}. ${LOCAL_TOOLCHAIN_INSTALL_USAGE}`;
+    }
+    const extra = parsed.command.slice(3);
+    if (extra.length > 0) {
+        return `Unexpected argument: ${extra[0]}. ${LOCAL_TOOLCHAIN_INSTALL_USAGE}`;
+    }
+    const board = optionalTrimmedStringAliasFlag(parsed, ["board", "board-id"], "board or board-id");
+    if (board.error)
+        return board.error;
+    const channel = optionalTrimmedStringFlag(parsed, "channel");
+    if (channel.error)
+        return channel.error;
+    const metadataRoot = optionalTrimmedStringFlag(parsed, "metadata-root");
+    if (metadataRoot.error)
+        return metadataRoot.error;
+    const sourceUrl = optionalTrimmedStringFlag(parsed, "source-url");
+    if (sourceUrl.error)
+        return sourceUrl.error;
+    const sourceReleaseRoot = optionalTrimmedStringFlag(parsed, "source-release-root");
+    if (sourceReleaseRoot.error)
+        return sourceReleaseRoot.error;
+    if (sourceUrl.value && sourceReleaseRoot.value) {
+        return "Use only one of --source-url or --source-release-root.";
+    }
+    const installRoot = optionalTrimmedStringFlag(parsed, "install-root");
+    if (installRoot.error)
+        return installRoot.error;
+    return {
+        boardId: board.value,
+        channel: channel.value,
+        metadataRoot: metadataRoot.value,
+        sourceUrl: sourceUrl.value,
+        sourceReleaseRoot: sourceReleaseRoot.value,
+        installRoot: installRoot.value,
+        force: booleanFlag(parsed, "force")
+    };
+}
+function localToolchainValidateRequest(parsed) {
+    const unknownFlag = firstUnknownFlag(parsed, ["json", "release-root"]);
+    if (unknownFlag) {
+        return `Unknown flag --${unknownFlag}. ${LOCAL_TOOLCHAIN_VALIDATE_USAGE}`;
+    }
+    const extra = parsed.command.slice(3);
+    if (extra.length > 0) {
+        return `Unexpected argument: ${extra[0]}. ${LOCAL_TOOLCHAIN_VALIDATE_USAGE}`;
+    }
+    const releaseRoot = optionalTrimmedStringFlag(parsed, "release-root");
+    if (releaseRoot.error) {
+        return releaseRoot.error;
+    }
+    return { releaseRoot: releaseRoot.value };
+}
+function localCompileTaishanPiRequest(parsed, auth) {
+    const unknownFlag = firstUnknownFlag(parsed, ["json", "source", "output", "release-root", "account", "account-id"]);
+    if (unknownFlag) {
+        return `Unknown flag --${unknownFlag}. ${LOCAL_COMPILE_TAISHANPI_USAGE}`;
+    }
+    const extra = parsed.command.slice(3);
+    if (extra.length > 0) {
+        return `Unexpected argument: ${extra[0]}. ${LOCAL_COMPILE_TAISHANPI_USAGE}`;
+    }
+    const source = optionalTrimmedStringFlag(parsed, "source");
+    if (source.error) {
+        return source.error;
+    }
+    const outputPath = optionalTrimmedStringFlag(parsed, "output");
+    if (outputPath.error) {
+        return outputPath.error;
+    }
+    if (!source.value || !outputPath.value) {
+        return LOCAL_COMPILE_TAISHANPI_USAGE;
+    }
+    const releaseRoot = optionalTrimmedStringFlag(parsed, "release-root");
+    if (releaseRoot.error) {
+        return releaseRoot.error;
+    }
+    const account = optionalTrimmedStringAliasFlag(parsed, ["account", "account-id"], "account or account-id");
+    if (account.error) {
+        return account.error;
+    }
+    return {
+        boardId: "taishanpi-1m-rk3566",
+        sourcePath: source.value,
+        outputPath: outputPath.value,
+        releaseRoot: releaseRoot.value,
+        accountId: account.value,
+        auth: localToolchainAuthContext(auth, account.value)
+    };
+}
+function localBuildQtSmokeRequest(parsed, auth) {
+    const unknownFlag = firstUnknownFlag(parsed, ["json", "source", "build-dir", "release-root", "target-name", "account", "account-id"]);
+    if (unknownFlag) {
+        return `Unknown flag --${unknownFlag}. ${LOCAL_BUILD_QT_SMOKE_USAGE}`;
+    }
+    const extra = parsed.command.slice(3);
+    if (extra.length > 0) {
+        return `Unexpected argument: ${extra[0]}. ${LOCAL_BUILD_QT_SMOKE_USAGE}`;
+    }
+    const buildDir = optionalTrimmedStringFlag(parsed, "build-dir");
+    if (buildDir.error) {
+        return buildDir.error;
+    }
+    if (!buildDir.value) {
+        return LOCAL_BUILD_QT_SMOKE_USAGE;
+    }
+    const source = optionalTrimmedStringFlag(parsed, "source");
+    if (source.error) {
+        return source.error;
+    }
+    const releaseRoot = optionalTrimmedStringFlag(parsed, "release-root");
+    if (releaseRoot.error) {
+        return releaseRoot.error;
+    }
+    const targetName = optionalTrimmedStringFlag(parsed, "target-name");
+    if (targetName.error) {
+        return targetName.error;
+    }
+    const account = optionalTrimmedStringAliasFlag(parsed, ["account", "account-id"], "account or account-id");
+    if (account.error) {
+        return account.error;
+    }
+    return {
+        sourceDir: source.value,
+        buildDir: buildDir.value,
+        releaseRoot: releaseRoot.value,
+        targetName: targetName.value,
+        accountId: account.value,
+        auth: localToolchainAuthContext(auth, account.value)
+    };
+}
+function localToolchainAuthContext(auth, accountId) {
+    return {
+        authenticated: auth.authenticated,
+        profile: auth.profile,
+        source: auth.source,
+        account_id: accountId
+    };
+}
 function usageEventsRequest(parsed) {
     const unknownFlag = firstUnknownFlag(parsed, ["json", "account", "account-id", "api-key-id", "from", "to", "limit"]);
     if (unknownFlag) {
@@ -3508,6 +4283,26 @@ function compactBody(input) {
     }
     return body;
 }
+async function readLocalFileForUpload(filePath, label) {
+    try {
+        const info = await stat(filePath);
+        if (!info.isFile()) {
+            return `${label} must point to a file: ${filePath}`;
+        }
+        const bytes = await readFile(filePath);
+        if (bytes.length === 0) {
+            return `${label} must not be empty: ${filePath}`;
+        }
+        return {
+            path: filePath,
+            bytes,
+            sha256: createHash("sha256").update(bytes).digest("hex")
+        };
+    }
+    catch (error) {
+        return `Could not read ${label} file ${filePath}: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
 function projectCreateBody(parsed) {
     const extra = parsed.command.slice(3);
     if (extra.length > 0) {
@@ -3801,8 +4596,15 @@ function renderServiceModeCatalog(catalog) {
         `  model_gateway=${catalog.boundaries.model_gateway}`,
         `  server_resource_orchestration=${catalog.boundaries.server_resource_orchestration}`,
         `  local_bridge=${catalog.boundaries.local_bridge}`,
+        catalog.boundaries.free_registered_operations ? `  free_registered_operations=${catalog.boundaries.free_registered_operations}` : "",
+        catalog.boundaries.paid_server_operations ? `  paid_server_operations=${catalog.boundaries.paid_server_operations}` : "",
+        catalog.allocation_rule ? `allocation_rule=${catalog.allocation_rule}` : "",
+        "free_registered_capabilities:",
+        ...(catalog.free_registered_capabilities ?? []).map((item) => `  - ${item.policy_id} workspace=${item.requires_server_workspace} lease=${item.allocates_server_resource_lease} meters=${item.meters.join(",") || "none"}`),
+        "paid_capabilities:",
+        ...(catalog.paid_capabilities ?? []).map((item) => `  - ${item.policy_id} workspace=${item.requires_server_workspace} lease=${item.allocates_server_resource_lease} meters=${item.meters.join(",") || "none"}`),
         "modes:"
-    ];
+    ].filter(Boolean);
     for (const mode of catalog.modes) {
         lines.push([
             `  ${mode.default ? "*" : "-"}`,
@@ -3843,6 +4645,15 @@ function renderPluginInstall(result) {
         if (item.command_hint) {
             lines.push(`    ${item.command_hint}`);
         }
+        if (item.warning) {
+            lines.push(`    warning=${item.warning}`);
+        }
+        if (item.mcp_registered !== undefined) {
+            lines.push(`    codex_mcp_registered=${item.mcp_registered}`);
+        }
+        if (item.mcp_warning) {
+            lines.push(`    warning=${item.mcp_warning}`);
+        }
     }
     return lines.join("\n");
 }
@@ -4214,10 +5025,13 @@ function renderBoardMethods(data) {
         method.operation,
         `status=${method.status}`,
         `runtime=${method.runtime}`,
+        method.access_tier ? `access=${method.access_tier}` : "",
         `endpoint=${method.http_method} ${method.path}`,
         `workspace=${method.requires_workspace}`,
+        method.allocates_server_workspace !== undefined ? `alloc_workspace=${method.allocates_server_workspace}` : "",
+        method.allocates_server_resource_lease !== undefined ? `alloc_lease=${method.allocates_server_resource_lease}` : "",
         `approval=${method.requires_approval}`
-    ].join(" ")).join("\n");
+    ].filter(Boolean).join(" ")).join("\n");
 }
 function renderBoardKnowledge(data) {
     const files = isJsonObject(data) && Array.isArray(data.knowledge_files)
@@ -4446,6 +5260,119 @@ function renderBuildWorkspaceSourcePatch(result) {
     }
     return lines.join("\n");
 }
+function renderLocalToolchainLatest(result) {
+    const lines = [
+        `board=${result.board_id}`,
+        `channel=${result.channel}`,
+        `version=${result.version}`,
+        `host=${result.host}`,
+        result.metadata_root ? `metadata_root=${result.metadata_root}` : "metadata=built-in"
+    ];
+    if (result.packages.length > 0) {
+        lines.push("packages:");
+        for (const pkg of result.packages) {
+            lines.push(`  ${pkg.id}@${pkg.version}`);
+        }
+    }
+    return lines.join("\n");
+}
+function renderLocalToolchainCurrent(result) {
+    if (!result.installed) {
+        return [
+            "No local toolchain installed.",
+            `board=${result.board_id}`,
+            `install_root=${result.install_root}`,
+            `registry=${result.registry_path}`
+        ].join("\n");
+    }
+    return [
+        "Local toolchain installed.",
+        `board=${result.board_id}`,
+        result.version ? `version=${result.version}` : "",
+        result.channel ? `channel=${result.channel}` : "",
+        result.release_root ? `release_root=${result.release_root}` : "",
+        `install_root=${result.install_root}`,
+        `registry=${result.registry_path}`
+    ].filter(Boolean).join("\n");
+}
+function renderLocalToolchainInstall(result) {
+    const lines = [
+        "Local toolchain installed.",
+        `board=${result.board_id}`,
+        `version=${result.version}`,
+        `channel=${result.channel}`,
+        `host=${result.host}`,
+        `install_root=${result.install_root}`,
+        `release_root=${result.release_root}`,
+        `registry=${result.registry_path}`,
+        `source=${result.source.kind}:${result.source.value}`,
+        result.source.downloaded_path ? `downloaded=${result.source.downloaded_path}` : "",
+        `validation=${result.validation.ok ? "ok" : "failed"}`
+    ].filter(Boolean);
+    if (result.installed_paths.length > 0) {
+        lines.push("installed_paths:");
+        for (const installedPath of result.installed_paths) {
+            lines.push(`  ${installedPath}`);
+        }
+    }
+    if (result.packages.length > 0) {
+        lines.push("packages:");
+        for (const pkg of result.packages) {
+            lines.push(`  ${pkg.id}@${pkg.version}`);
+        }
+    }
+    return lines.join("\n");
+}
+function renderLocalToolchainValidation(result) {
+    const lines = [
+        result.ok ? "Local toolchain ready." : "Local toolchain not ready.",
+        `board=${result.board_id}`,
+        `host=${result.host.platform}/${result.host.arch}`,
+        `release_root=${result.release_root}`
+    ];
+    for (const check of result.checked_paths) {
+        lines.push(`${check.exists ? "ok" : "missing"} ${check.label}: ${check.path}`);
+    }
+    if (result.notes.length > 0) {
+        lines.push("notes:");
+        for (const note of result.notes) {
+            lines.push(`  ${note}`);
+        }
+    }
+    return lines.join("\n");
+}
+function renderLocalCompileResult(result) {
+    const lines = [
+        `${result.operation} succeeded.`,
+        `board=${result.board_id}`,
+        result.account_id ? `account=${result.account_id}` : "",
+        `auth=${result.auth.authenticated ? "authenticated" : "anonymous"} profile=${result.auth.profile}${result.auth.source ? ` source=${result.auth.source}` : ""}`,
+        `source=${result.source_path}`,
+        result.build_dir ? `build_dir=${result.build_dir}` : "",
+        `artifact=${result.artifact_path}`,
+        `size=${result.artifact_size_bytes}`,
+        `sha256=${result.artifact_sha256}`,
+        result.file_info ? `file=${result.file_info}` : "",
+        `manifest=${result.manifest_path}`
+    ].filter(Boolean);
+    for (const command of result.commands) {
+        lines.push(`command_exit=${command.exit_code} cwd=${command.cwd}`);
+        lines.push(`  ${command.command.join(" ")}`);
+        if (command.stdout_tail.length > 0) {
+            lines.push("  stdout_tail:");
+            for (const line of command.stdout_tail.slice(-12)) {
+                lines.push(`    ${line}`);
+            }
+        }
+        if (command.stderr_tail.length > 0) {
+            lines.push("  stderr_tail:");
+            for (const line of command.stderr_tail.slice(-12)) {
+                lines.push(`    ${line}`);
+            }
+        }
+    }
+    return lines.join("\n");
+}
 function renderDoctor(result) {
     const lines = [
         `${result.status === "ready" ? "Ready" : "Not ready"}: ${result.summary_for_user}`,
@@ -4616,6 +5543,46 @@ function renderJob(job) {
     }
     return lines.join("\n");
 }
+function renderBootLogoPackageResult(result) {
+    const lines = [renderJob(result.task)];
+    if (result.downloaded_artifact) {
+        lines.push("downloaded_package:");
+        lines.push(`  artifact=${result.downloaded_artifact.artifact_id}`);
+        lines.push(`  output=${result.downloaded_artifact.output_path}`);
+        lines.push(`  size=${result.downloaded_artifact.size_bytes}`);
+    }
+    lines.push("next=merge the downloaded package with the local base image, then flash only after explicit approval.");
+    return lines.join("\n");
+}
+function renderDtbPackageResult(result) {
+    const lines = [renderJob(result.task)];
+    if (result.downloaded_artifact) {
+        lines.push("downloaded_package:");
+        lines.push(`  artifact=${result.downloaded_artifact.artifact_id}`);
+        lines.push(`  output=${result.downloaded_artifact.output_path}`);
+        lines.push(`  size=${result.downloaded_artifact.size_bytes}`);
+    }
+    lines.push("next=merge the downloaded DTB package with the local base image, then flash only after explicit approval.");
+    return lines.join("\n");
+}
+function renderBootLogoComposeResult(result) {
+    const label = result.operation_kind === "image.dtb.compose" ? "DTB" : "Boot-logo";
+    return [
+        result.ready_for_flash ? `${label} compose ready for flash review.` : `${label} compose created a guarded local result.`,
+        `board=${result.board_id}`,
+        result.variant_id ? `variant=${result.variant_id}` : "",
+        `package=${result.package_path}`,
+        `base=${result.base_image_path}`,
+        `output=${result.output_image_path}`,
+        `manifest=${result.manifest_path}`,
+        `strategy=${result.local_merge_strategy}`,
+        `patches=${result.patch_operations_applied}/${result.patch_operations_total}`,
+        `replacement_applied=${result.replacement_applied}`,
+        `ready_for_flash=${result.ready_for_flash}`,
+        `cross_platform=${result.cross_platform} platform=${result.platform}/${result.arch}`,
+        result.summary_for_user
+    ].filter(Boolean).join("\n");
+}
 function safeArtifactOutputFileName(name) {
     return name.replace(/[^A-Za-z0-9._-]+/g, "_") || "artifact.out";
 }
@@ -5095,7 +6062,7 @@ async function waitForever() {
     return 0;
 }
 function printHelp() {
-    console.log(`embed CLI
+    printCliHelp(`embed CLI
 
 Usage:
   embed <command> [options]
@@ -5117,13 +6084,19 @@ Main workflow:
      embed model default
   4. Run a natural-language local tool loop:
      embed agent run --prompt "验证开发板状态"
-  5. Pick a cloud build template:
+  5. Validate or use the local TaishanPi toolchain:
+     embed local toolchain latest
+     embed local toolchain install --source-url <toolchain.tar.gz>
+     embed local toolchain validate
+     embed local compile taishanpi --source ./main.c --output ./.embed-labs/build/main
+     embed local build qt-smoke --build-dir ./.embed-labs/build/qt-smoke
+  6. Pick a cloud build template:
      embed board registry list
      embed board methods taishanpi-1m-rk3566
      embed board knowledge taishanpi-1m-rk3566
      embed build template list
      embed build template show <template_id>
-  6. Provision and populate a build workspace:
+  7. Provision and populate a build workspace:
      embed build workspace provision --account <account_id> --project <project_id> --template <template_id>
      embed build resource lease create --workspace <workspace_id> --execution-mode cloud_worker
      embed build workspace source put <workspace_id> --file ./main.c:src/main.c
@@ -5132,13 +6105,15 @@ Main workflow:
      embed build workspace source search <workspace_id> --query init --glob "**/*.c"
      embed build workspace source patch <workspace_id> --patch ./fix.patch
      embed build workspace release <workspace_id> --dry-run
-  7. Generate application source on the server and follow artifacts:
+  8. Generate application source on the server and follow artifacts:
      embed build application generate --workspace <workspace_id> --prompt "Create a minimal Linux app" --provider bai --model gpt-5.2
      embed build application compile --workspace <workspace_id> --source app/generated.c --execution-mode docker_worker
      embed build image generate --workspace <workspace_id> --prompt "Generate a minimal TaishanPi image"
+     embed build image boot-logo --logo ./logo.png --board taishanpi --variant 1M-RK3566 --output ./boot-logo-package.json
+     embed image boot-logo compose --package ./boot-logo-package.json --base-image ./boot.img --output ./boot-logo.img
      embed cloud task artifacts <task_id>
      embed artifact download <artifact_id> --output ./artifact.bin
-  8. Check credits or create a recharge QR:
+  9. Check credits or create a recharge QR:
      embed billing balance --account <account_id>
      embed billing tokens --account <account_id>
      embed billing ledger --account <account_id>
@@ -5153,7 +6128,17 @@ Local hardware:
   embed agent run --prompt "部署生成的泰山派应用" --host 198.19.77.2 --artifact-task <task_id> --remote-path /userdata/embed-labs/apps/app --approve --run
   embed tool list
   embed tool call device.probe --input-json '{"host":"198.19.77.2","ports":[22,15301]}'
+  embed tool call wifi.scan --input-json '{"host":"198.19.77.2","user":"root"}'
+  embed tool call chip.temperature --input-json '{"host":"198.19.77.2","user":"root"}'
+  embed tool call qml.runtime.status --input-json '{"host":"198.19.77.2","user":"root","port":18130}'
   embed device list
+  embed local toolchain latest
+  embed local toolchain current
+  embed local toolchain install --source-url <toolchain.tar.gz>
+  embed local toolchain validate
+  embed local compile taishanpi --source ./main.c --output ./.embed-labs/build/main
+  embed local build qt-smoke --build-dir ./.embed-labs/build/qt-smoke
+  embed image boot-logo compose --package ./boot-logo-package.json --base-image ./boot.img --output ./boot-logo.img
   embed deploy taishanpi --host 198.19.77.2 --artifact ./artifact.bin --approve --run
   embed flash plan --board <rp2350|taishanpi>
 
@@ -5188,7 +6173,7 @@ function printHelpTopic(topic) {
         printCommandReference();
         return;
     }
-    console.log(`Unknown help topic: ${topic}
+    printCliHelp(`Unknown help topic: ${topic}
 
 Available topics:
   embed help getting-started
@@ -5196,7 +6181,7 @@ Available topics:
 `);
 }
 function printGettingStartedHelp() {
-    console.log(`embed getting started
+    printCliHelp(`embed getting started
 
 After npm install, use the installed embed binary directly:
 
@@ -5225,6 +6210,9 @@ Cloud build path:
   embed model list
   embed model default
   embed agent run --prompt "验证开发板状态"
+  embed local toolchain validate
+  embed local compile taishanpi --source ./main.c --output ./.embed-labs/build/main
+  embed local build qt-smoke --build-dir ./.embed-labs/build/qt-smoke
   embed board registry list
   embed board registry show taishanpi-1m-rk3566
   embed board methods taishanpi-1m-rk3566
@@ -5242,6 +6230,8 @@ Cloud build path:
   embed build application generate --workspace <workspace_id> --prompt "Create a minimal Linux app" --provider bai --model gpt-5.2
   embed build application compile --workspace <workspace_id> --source app/generated.c --execution-mode docker_worker
   embed build image generate --workspace <workspace_id> --prompt "Generate a minimal TaishanPi image"
+  embed build image boot-logo --logo ./logo.png --board taishanpi --variant 1M-RK3566 --output ./boot-logo-package.json
+  embed image boot-logo compose --package ./boot-logo-package.json --base-image ./boot.img --output ./boot-logo.img
   embed cloud task status <task_id>
   embed cloud task artifacts <task_id>
   embed artifact download <artifact_id> --output ./artifact.bin
@@ -5279,7 +6269,7 @@ Use --json on commands when scripting or running in CI.
 `);
 }
 function printCommandReference() {
-    console.log(`embed CLI
+    printCliHelp(`embed CLI
 
 Usage:
   embed doctor [--json]
@@ -5299,7 +6289,7 @@ Usage:
   embed board methods <template_id> [--json]
   embed board knowledge <template_id> [--json]
   embed board knowledge file <template_id> --source board_pack|build_template|registry --path <relative_path> [--output <local_path>] [--json]
-  embed agent run --prompt <request> [--account <account_id>] [--workspace <workspace_id>] [--provider stub|openai|bai|cc|claude-code] [--model <model>] [--max-tool-calls 4] [--host <ip>] [--ports 22,15301] [--artifact <local_file>|--artifact-id <artifact_id>|--artifact-task <task_id>] [--artifact-output <path>] [--remote-path <path>] [--run] [--approve] [--json]
+  embed agent run --prompt <request> [--account <account_id>] [--workspace <workspace_id>] [--provider stub|openai|bai|cc|claude-code] [--model <model>] [--max-tool-calls 6] [--host <ip>] [--ports 22,15301] [--artifact <local_file>|--artifact-id <artifact_id>|--artifact-task <task_id>] [--artifact-output <path>] [--remote-path <path>] [--run] [--approve] [--json]
   embed run <natural language request> [--provider stub|openai|bai|cc|claude-code] [--approve] [--json]
   embed tool list [--json]
   embed tool call <capability_id> [--input-json '<json>'] [--approve] [--json]
@@ -5344,7 +6334,22 @@ Usage:
   embed build application generate --workspace <workspace_id> --prompt <request> [--account <account_id>] [--target <source_path>] [--provider stub|openai|bai|cc|claude-code] [--model <model>] [--json]
   embed build application compile --workspace <workspace_id> [--account <account_id>] [--source <source_path>] [--execution-mode docker_worker|server_direct|dry_run] [--compiler auto|cc|gcc|clang|aarch64-linux-gnu-gcc] [--json]
   embed build image generate --workspace <workspace_id> --prompt <request> [--account <account_id>] [--image-profile <profile_id>] [--provider stub|openai|bai|cc|claude-code] [--model <model>] [--execution-mode cloud_worker|dry_run] [--worker-pool <pool>] [--json]
+  embed build image boot-logo --logo <local_image> [--account <account_id>] [--project <project_id>] [--board taishanpi] [--variant 1M-RK3566] [--kernel-logo <local_image>] [--rotate -90] [--scale 100] [--output <package.json>] [--json]
+  embed image boot-logo compose --package <boot-logo-package.json> --base-image <boot.img|image.img> --output <image> [--manifest <manifest.json>] [--force] [--json]
+  embed local toolchain latest [--board taishanpi-1m-rk3566] [--channel stable] [--metadata-root <path>] [--json]
+  embed local toolchain current [--install-root <path>] [--json]
+  embed local toolchain install [--board taishanpi-1m-rk3566] [--channel stable] [--metadata-root <path>] [--source-url <tar.gz-url>|--source-release-root <path>] [--install-root <path>] [--force] [--json]
+  embed local toolchain validate [--release-root <path>] [--json]
+  embed local compile taishanpi --source <main.c|main.cpp> --output <artifact> [--release-root <path>] [--account <account_id>] [--json]
+  embed local build qt-smoke --build-dir <dir> [--source <qt-smoke-dir>] [--release-root <path>] [--account <account_id>] [--json]
   embed debug tools [--json]
+  embed tool list [--json]
+  embed tool call wifi.scan --input-json '{"host":"198.19.77.2","user":"root"}' [--json]
+  embed tool call bluetooth.scan --input-json '{"host":"198.19.77.2","user":"root","duration_seconds":8}' [--json]
+  embed tool call chip.cpu.frequency --input-json '{"host":"198.19.77.2","user":"root"}' [--json]
+  embed tool call chip.temperature --input-json '{"host":"198.19.77.2","user":"root"}' [--json]
+  embed tool call qml.runtime.status --input-json '{"host":"198.19.77.2","user":"root","port":18130}' [--json]
+  embed tool call qml.runtime.start --input-json '{"host":"198.19.77.2","user":"root","port":18130}' [--json]
   embed deploy taishanpi --host <ip> --artifact <local_file> --approve [--remote-path /userdata/embed-labs/apps/app] [--run] [--json]
   embed board deploy taishanpi --host <ip> --artifact <local_file> --approve [--remote-path /userdata/embed-labs/apps/app] [--run] [--json]
   embed device list [--json]
@@ -5383,6 +6388,23 @@ Environment:
   CODEX_HOME=~/.codex
 `);
 }
+function printCliHelp(text) {
+    console.log(formatCliHelp(text));
+}
+function formatCliHelp(text) {
+    if (currentCommandName() !== "embedlabs") {
+        return text;
+    }
+    return text
+        .replace(/^embed CLI$/m, "embedlabs CLI")
+        .replace(/^embed getting started$/m, "embedlabs getting started")
+        .replace("After npm install, use the installed embed binary directly:", "After npm install, use the installed embedlabs binary directly:")
+        .replace(/(^|\n)(\s*)embed(\s+)/g, "$1$2embedlabs$3");
+}
+function currentCommandName() {
+    const invoked = basename(process.argv[1] ?? "");
+    return invoked.startsWith("embedlabs") ? "embedlabs" : "embed";
+}
 main(process.argv.slice(2))
     .then((code) => {
     process.exitCode = code;