@kvell007/embed-labs-cli 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/index.js

@@ -1,13 +1,19 @@
 #!/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));
+const SOURCE_CHECKOUT_ROOT = resolve(CLI_MODULE_DIR, "..", "..", "..");
 const qrcodeTerminal = require("qrcode-terminal");
 const DEFAULT_BRIDGE_URL = process.env.EMBED_BRIDGE_URL ?? "http://127.0.0.1:18083";
 const DEFAULT_CLOUD_API_URL = process.env.EMBED_CLOUD_API_URL ?? "http://127.0.0.1:18100";
@@ -71,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]\nDefault source: the production download channel at download.embedboard.com.";
+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]";
@@ -79,9 +95,10 @@ 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 MCP_TOOL_EVENT_USAGE = "Usage: embed mcp log --tool <tool_name> [--client codex|opencode] [--mode local_ai|server_ai] [--server-model-used true|false] [--success true|false] [--request-id <id>] [--duration-ms <ms>] [--input-summary <text>] [--output-summary <text>] [--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]";
 const CLOUD_TASK_EVENT_APPEND_USAGE = "Usage: embed cloud task event append <task_id> [--state <state>] [--progress-stage <stage>|--stage <stage>] [--progress-text <text>|--message <text>] [--progress-percent 0-100] [--severity info|warning|error] [--type <event_type>] [--artifact-json '<json>'] [--evidence-json '<json>'] [--json]";
 const TASK_STATES = new Set([
@@ -351,6 +368,16 @@ async function main(argv) {
                 USAGE_EVENTS_USAGE
             ].join("\n")), undefined, 2);
         }
+        if (area === "mcp") {
+            if (action === "log" || action === "tool-event") {
+                const body = mcpToolEventBody(parsed);
+                if (typeof body === "string") {
+                    return output(parsed, fail("invalid_args", body), undefined, 2);
+                }
+                return output(parsed, await cloudPost("/v1/mcp/tool-events", body), renderMcpToolEvent);
+            }
+            return output(parsed, fail("invalid_args", MCP_TOOL_EVENT_USAGE), undefined, 2);
+        }
         if (area === "billing") {
             if (action === "statement") {
                 const request = billingStatementRequest(parsed);
@@ -472,6 +499,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];
@@ -617,6 +713,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,
@@ -633,7 +767,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") {
@@ -1304,16 +1440,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,
@@ -1322,7 +1458,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,
@@ -1398,7 +1534,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."
@@ -1407,12 +1543,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) {
@@ -1448,20 +1589,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);
@@ -1476,13 +1619,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 = resolve(process.cwd(), "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."
@@ -1492,9 +1635,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);
@@ -1503,13 +1646,38 @@ async function resolveOpenCodePluginSource(context) {
         }
         return ok({ packagePath: tarball, sourceLabel: tarball, version: item.version ?? context.manifest?.version });
     }
-    const packagePath = resolve(process.cwd(), "platform_plugins", "opencode_plugin");
+    const packagePath = sourceCheckoutPath("platform_plugins", "opencode_plugin");
     if (!await pathExists(join(packagePath, "package.json"))) {
         return fail("plugin_source_not_found", "Could not find OpenCode plugin source in this checkout.", {
             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`;
@@ -1645,13 +1813,204 @@ 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"
-        ? resolve(process.cwd(), "platform_plugins", "codex_plugin", "plugins", "dbt-agent", ".codex-plugin", "plugin.json")
-        : resolve(process.cwd(), "platform_plugins", "opencode_plugin", "package.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"));
         return parsed.version;
@@ -1661,8 +2020,11 @@ async function localPluginVersion(kind) {
     }
 }
 async function localPluginSourcesAvailable() {
-    return await pathExists(resolve(process.cwd(), "platform_plugins", "codex_plugin", "plugins", "dbt-agent", ".codex-plugin", "plugin.json"))
-        && await pathExists(resolve(process.cwd(), "platform_plugins", "opencode_plugin", "package.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) {
+    return resolve(SOURCE_CHECKOUT_ROOT, ...segments);
 }
 async function pathExists(pathValue) {
     try {
@@ -2098,6 +2460,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({
@@ -2778,6 +3170,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) {
@@ -3110,6 +3727,73 @@ function usageRecordBody(parsed) {
         created_at: createdAtResult.value
     });
 }
+function mcpToolEventBody(parsed) {
+    const unknownFlag = firstUnknownFlag(parsed, [
+        "json",
+        "account",
+        "account-id",
+        "tool",
+        "client",
+        "mode",
+        "server-model-used",
+        "success",
+        "request-id",
+        "duration-ms",
+        "input-summary",
+        "output-summary"
+    ]);
+    if (unknownFlag) {
+        return `Unknown flag --${unknownFlag}. ${MCP_TOOL_EVENT_USAGE}`;
+    }
+    const extra = parsed.command.slice(2);
+    if (extra.length > 0) {
+        return `Unexpected argument: ${extra[0]}. ${MCP_TOOL_EVENT_USAGE}`;
+    }
+    const toolResult = optionalTrimmedStringFlag(parsed, "tool");
+    if (toolResult.error)
+        return toolResult.error;
+    if (!toolResult.value)
+        return MCP_TOOL_EVENT_USAGE;
+    const accountResult = optionalTrimmedStringAliasFlag(parsed, ["account", "account-id"], "account or account-id");
+    if (accountResult.error)
+        return accountResult.error;
+    const clientResult = optionalTrimmedStringFlag(parsed, "client");
+    if (clientResult.error)
+        return clientResult.error;
+    const modeResult = optionalTrimmedStringFlag(parsed, "mode");
+    if (modeResult.error)
+        return modeResult.error;
+    const requestIdResult = optionalTrimmedStringFlag(parsed, "request-id");
+    if (requestIdResult.error)
+        return requestIdResult.error;
+    const inputSummaryResult = optionalTrimmedStringFlag(parsed, "input-summary");
+    if (inputSummaryResult.error)
+        return inputSummaryResult.error;
+    const outputSummaryResult = optionalTrimmedStringFlag(parsed, "output-summary");
+    if (outputSummaryResult.error)
+        return outputSummaryResult.error;
+    const durationResult = optionalNonNegativeIntegerFlag(parsed, "duration-ms");
+    if (durationResult.error)
+        return durationResult.error;
+    const serverModelUsed = optionalBooleanFlag(parsed, "server-model-used");
+    if (typeof serverModelUsed === "string")
+        return serverModelUsed;
+    const success = optionalBooleanFlag(parsed, "success");
+    if (typeof success === "string")
+        return success;
+    return compactBody({
+        account_id: accountResult.value,
+        tool_name: toolResult.value,
+        client: clientResult.value,
+        mode: modeResult.value,
+        server_model_used: serverModelUsed,
+        success,
+        request_id: requestIdResult.value,
+        duration_ms: durationResult.value,
+        input_summary: inputSummaryResult.value,
+        output_summary: outputSummaryResult.value
+    });
+}
 function usageSummaryRequest(parsed) {
     const unknownFlag = firstUnknownFlag(parsed, ["json", "account", "account-id", "api-key-id", "from", "to"]);
     if (unknownFlag) {
@@ -3445,6 +4129,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) {
@@ -3502,6 +4361,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) {
@@ -3795,8 +4674,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 ? "*" : "-"}`,
@@ -3837,6 +4723,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");
 }
@@ -3920,6 +4815,20 @@ function renderUsageRecord(record) {
         `created_at=${record.created_at}`
     ].filter(Boolean).join(" ");
 }
+function renderMcpToolEvent(event) {
+    return [
+        `${event.event_id} tool=${event.tool_name}`,
+        event.account_id ? `account=${event.account_id}` : "",
+        event.api_key_id ? `api_key=${event.api_key_id}` : "",
+        `client=${event.client}`,
+        `mode=${event.mode}`,
+        `server_model_used=${event.server_model_used}`,
+        `success=${event.success}`,
+        event.request_id ? `request=${event.request_id}` : "",
+        event.duration_ms !== undefined ? `duration_ms=${event.duration_ms}` : "",
+        `created_at=${event.created_at}`
+    ].filter(Boolean).join(" ");
+}
 function renderUsageSummary(summary) {
     const lines = [
         summary.account_id ? `account=${summary.account_id}` : "",
@@ -4208,10 +5117,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)
@@ -4440,6 +5352,123 @@ 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",
+        result.download ? `download=${result.download.mirror_kind}:${result.download.source_url}` : "",
+        result.download ? `archive_sha256=${result.download.archive.sha256}` : "",
+        result.download ? `archive_size_bytes=${result.download.archive.size_bytes}` : "",
+        result.download_error ? `download_error=${result.download_error}` : ""
+    ].filter(Boolean);
+    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}`,
@@ -4610,6 +5639,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";
 }
@@ -4808,6 +5877,22 @@ function stringFlag(parsed, name) {
 function booleanFlag(parsed, name) {
     return parsed.flags[name] === true;
 }
+function optionalBooleanFlag(parsed, name) {
+    const values = flagValues(parsed, name);
+    if (values.length === 0)
+        return undefined;
+    const value = values[values.length - 1];
+    if (value === true)
+        return true;
+    if (typeof value !== "string")
+        return `--${name} must be true or false.`;
+    const normalized = value.trim().toLowerCase();
+    if (["1", "true", "yes", "y", "on"].includes(normalized))
+        return true;
+    if (["0", "false", "no", "n", "off"].includes(normalized))
+        return false;
+    return `--${name} must be true or false.`;
+}
 function switchFlag(parsed, name) {
     const values = flagValues(parsed, name);
     for (const value of values) {
@@ -5089,7 +6174,7 @@ async function waitForever() {
     return 0;
 }
 function printHelp() {
-    console.log(`embed CLI
+    printCliHelp(`embed CLI
 
 Usage:
   embed <command> [options]
@@ -5111,13 +6196,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
+     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
@@ -5126,13 +6217,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>
@@ -5147,7 +6240,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
+  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>
 
@@ -5182,7 +6285,7 @@ function printHelpTopic(topic) {
         printCommandReference();
         return;
     }
-    console.log(`Unknown help topic: ${topic}
+    printCliHelp(`Unknown help topic: ${topic}
 
 Available topics:
   embed help getting-started
@@ -5190,7 +6293,7 @@ Available topics:
 `);
 }
 function printGettingStartedHelp() {
-    console.log(`embed getting started
+    printCliHelp(`embed getting started
 
 After npm install, use the installed embed binary directly:
 
@@ -5219,6 +6322,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
@@ -5236,6 +6342,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
@@ -5273,7 +6381,7 @@ Use --json on commands when scripting or running in CI.
 `);
 }
 function printCommandReference() {
-    console.log(`embed CLI
+    printCliHelp(`embed CLI
 
 Usage:
   embed doctor [--json]
@@ -5293,7 +6401,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]
@@ -5338,7 +6446,26 @@ 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]
+      Defaults to the production download channel at download.embedboard.com.
+  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 tool call rp2350.monitor.status [--json]
+  embed tool call rp2350.monitor.logic.capture --input-json '{"pin_base":16,"pin_count":4,"sample_rate":1000000,"samples":4096}' [--json]
+  embed tool call rp2350.monitor.logic.decode --input-json '{"input_path":".embed-labs/rp2350-monitor/captures/logic.jsonl","decoder":"summary"}' [--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]
@@ -5377,6 +6504,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;