@kvell007/embed-labs-local-bridge 0.1.0-alpha.21 → 0.1.0-alpha.23

package/dist/tools.js

@@ -1,1254 +0,0 @@
-import net from "node:net";
-import { fail, ok } from "@embed-labs/protocol";
-import { buildFlashPlan, captureRp2350MonitorLogic, decodeRp2350MonitorLogic, deployTaishanPiApplication, getRp2350MonitorStatus, getTaishanPiQmlRuntimeStatus, probeDevices, readTaishanPiCpuFrequency, readTaishanPiTemperature, rp2350MonitorCommandNeedsApproval, runRp2350MonitorCommand, scanTaishanPiBluetoothDevices, scanDebugTools, scanHardware, scanTaishanPiWifiNetworks, startTaishanPiQmlRuntime, validateTaishanPiDeployRequest } from "./hardware.js";
-import { startFlashJob } from "./jobs.js";
-const PROBE_REQUEST_FIELDS = new Set(["host", "ports", "serial_paths", "timeout_ms"]);
-const FLASH_REQUEST_FIELDS = new Set(["board_id", "variant_id", "hardware_profile_id", "profile_id", "image_dir", "artifact_path", "target_volume_path"]);
-const TAISHANPI_LIVE_FIELDS = new Set(["board_id", "variant_id", "host", "user", "timeout_seconds", "interface", "duration_seconds", "port", "force_restart"]);
-const RP2350_MONITOR_BASE_FIELDS = new Set(["transport", "serial_path", "host", "port", "baud", "timeout_ms", "monitor_root"]);
-const RP2350_MONITOR_STATUS_FIELDS = new Set([...RP2350_MONITOR_BASE_FIELDS, "include_caps"]);
-const RP2350_MONITOR_COMMAND_FIELDS = new Set([...RP2350_MONITOR_BASE_FIELDS, "command", "args"]);
-const RP2350_MONITOR_LOGIC_CAPTURE_FIELDS = new Set([
-    ...RP2350_MONITOR_BASE_FIELDS,
-    "pin_base",
-    "pin_count",
-    "sample_rate",
-    "samples",
-    "output_path",
-    "pull",
-    "release",
-    "wait_timeout_ms",
-    "read_timeout_ms",
-    "pre_samples",
-    "post_samples",
-    "search_samples",
-    "burst_count",
-    "trigger_pin",
-    "trigger_mode",
-    "trigger_level",
-    "trigger_mask",
-    "trigger_value",
-    "channel_names",
-    "pin_pulls"
-]);
-const RP2350_MONITOR_LOGIC_DECODE_FIELDS = new Set([
-    "input_path",
-    "decoder",
-    "output_path",
-    "capture_id",
-    "start_sample",
-    "end_sample",
-    "pins",
-    "rx_pin",
-    "baud",
-    "data_bits",
-    "parity",
-    "stop_bits",
-    "invert",
-    "sck_pin",
-    "mosi_pin",
-    "miso_pin",
-    "cs_pin",
-    "mode",
-    "cs_active_high",
-    "word_bits",
-    "bit_order",
-    "sda_pin",
-    "scl_pin",
-    "monitor_root"
-]);
-export function listToolCapabilities() {
-    return {
-        observed_at: new Date().toISOString(),
-        capabilities: [
-            {
-                capability_id: "debug.tools.scan",
-                display_name: "Debug Tool Scan",
-                description: "Scan OpenOCD, probe-rs, pyOCD, and J-Link command availability without opening a debug session.",
-                runtime: "local_bridge",
-                category: "debug",
-                destructive: false,
-                requires_approval: false,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {}
-                }
-            },
-            {
-                capability_id: "device.scan",
-                display_name: "Device Scan",
-                description: "Detect USB, serial, UF2, Rockchip, and TaishanPi USB ECM devices visible to the local machine.",
-                runtime: "local_bridge",
-                category: "device",
-                destructive: false,
-                requires_approval: false,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {}
-                }
-            },
-            {
-                capability_id: "device.probe",
-                display_name: "Device Probe",
-                description: "Probe selected TCP ports and serial paths with bounded timeouts.",
-                runtime: "local_bridge",
-                category: "device",
-                destructive: false,
-                requires_approval: false,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {
-                        host: { type: "string" },
-                        ports: { type: "array", items: { type: "integer", minimum: 1, maximum: 65535 } },
-                        serial_paths: { type: "array", items: { type: "string" } },
-                        timeout_ms: { type: "number", minimum: 100, maximum: 5000 }
-                    }
-                }
-            },
-            {
-                capability_id: "wifi.scan",
-                display_name: "TaishanPi WiFi Scan",
-                description: "Scan nearby WiFi networks from the connected TaishanPi Linux runtime over SSH.",
-                runtime: "local_bridge",
-                category: "board",
-                destructive: false,
-                requires_approval: false,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: taishanPiLiveInputSchema({
-                    interface: { type: "string" }
-                })
-            },
-            {
-                capability_id: "bluetooth.scan",
-                display_name: "TaishanPi Bluetooth Scan",
-                description: "Scan nearby Bluetooth devices from the connected TaishanPi Linux runtime over SSH when a Bluetooth controller is initialized.",
-                runtime: "local_bridge",
-                category: "board",
-                destructive: false,
-                requires_approval: false,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: taishanPiLiveInputSchema({
-                    duration_seconds: { type: "number", minimum: 3, maximum: 30 }
-                })
-            },
-            {
-                capability_id: "chip.cpu.frequency",
-                display_name: "TaishanPi CPU Frequency",
-                description: "Read current TaishanPi CPU frequency values from the Linux runtime over SSH.",
-                runtime: "local_bridge",
-                category: "board",
-                destructive: false,
-                requires_approval: false,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: taishanPiLiveInputSchema()
-            },
-            {
-                capability_id: "chip.temperature",
-                display_name: "TaishanPi Temperature",
-                description: "Read TaishanPi thermal-zone temperatures from the Linux runtime over SSH.",
-                runtime: "local_bridge",
-                category: "board",
-                destructive: false,
-                requires_approval: false,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: taishanPiLiveInputSchema()
-            },
-            {
-                capability_id: "qml.runtime.status",
-                display_name: "TaishanPi QML Runtime Status",
-                description: "Check whether the TaishanPi QtQuick board runtime is installed and reachable.",
-                runtime: "local_bridge",
-                category: "board",
-                destructive: false,
-                requires_approval: false,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: taishanPiLiveInputSchema({
-                    port: { type: "number", minimum: 1, maximum: 65535 }
-                })
-            },
-            {
-                capability_id: "qml.runtime.start",
-                display_name: "TaishanPi QML Runtime Start",
-                description: "Start the TaishanPi QtQuick board runtime over SSH and verify that its TCP port is reachable.",
-                runtime: "local_bridge",
-                category: "board",
-                destructive: false,
-                requires_approval: false,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: taishanPiLiveInputSchema({
-                    port: { type: "number", minimum: 1, maximum: 65535 },
-                    force_restart: { type: "boolean" }
-                })
-            },
-            {
-                capability_id: "rp2350.monitor.status",
-                display_name: "RP2350 Monitor Status",
-                description: "Auto-detect or connect to RP2350-Monitor over USB CDC or Wi-Fi TCP and read status, logic analyzer caps, probe caps, pins, and channels.",
-                runtime: "local_bridge",
-                category: "board",
-                destructive: false,
-                requires_approval: false,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: rp2350MonitorBaseInputSchema({
-                    include_caps: { type: "boolean" }
-                })
-            },
-            {
-                capability_id: "rp2350.monitor.logic.capture",
-                display_name: "RP2350 Monitor Logic Capture",
-                description: "Capture GPIO logic-analyzer samples through RP2350-Monitor and write a compact local JSONL capture file for decoding or evidence.",
-                runtime: "local_bridge",
-                category: "board",
-                destructive: false,
-                requires_approval: false,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: rp2350MonitorBaseInputSchema({
-                    pin_base: { type: "number", minimum: 0, maximum: 47 },
-                    pin_count: { type: "number", minimum: 1, maximum: 16 },
-                    sample_rate: { type: "number", minimum: 1, maximum: 125000000 },
-                    samples: { type: "number", minimum: 1, maximum: 1048576 },
-                    output_path: { type: "string" },
-                    pull: { enum: ["none", "up", "down"] },
-                    release: { type: "boolean" },
-                    wait_timeout_ms: { type: "number", minimum: 1000, maximum: 120000 },
-                    read_timeout_ms: { type: "number", minimum: 1000, maximum: 120000 },
-                    pre_samples: { type: "number", minimum: 0 },
-                    post_samples: { type: "number", minimum: 0 },
-                    search_samples: { type: "number", minimum: 0 },
-                    burst_count: { type: "number", minimum: 1, maximum: 32 },
-                    trigger_pin: { type: "number", minimum: 0, maximum: 47 },
-                    trigger_mode: { enum: ["level", "rising", "falling", "pattern"] },
-                    trigger_level: { type: "boolean" },
-                    trigger_mask: { type: "number", minimum: 0 },
-                    trigger_value: { type: "number", minimum: 0 },
-                    channel_names: { type: "object", additionalProperties: { type: "string" } },
-                    pin_pulls: { type: "object", additionalProperties: { enum: ["none", "up", "down"] } }
-                }, ["pin_base", "pin_count"])
-            },
-            {
-                capability_id: "rp2350.monitor.logic.decode",
-                display_name: "RP2350 Monitor Logic Decode",
-                description: "Decode a local RP2350-Monitor JSONL logic capture as summary, edges, UART, SPI, or I2C without touching hardware.",
-                runtime: "local_bridge",
-                category: "board",
-                destructive: false,
-                requires_approval: false,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["input_path"],
-                    properties: {
-                        input_path: { type: "string" },
-                        decoder: { enum: ["summary", "bursts", "edges", "uart", "spi", "i2c"] },
-                        output_path: { type: "string" },
-                        capture_id: { type: "number", minimum: 0 },
-                        start_sample: { type: "number", minimum: 0 },
-                        end_sample: { type: "number", minimum: 0 },
-                        pins: { type: "array", items: { type: "number", minimum: 0, maximum: 47 } },
-                        rx_pin: { type: "number", minimum: 0, maximum: 47 },
-                        baud: { type: "number", minimum: 1 },
-                        data_bits: { type: "number", minimum: 5, maximum: 9 },
-                        parity: { enum: ["none", "even", "odd"] },
-                        stop_bits: { type: "number", minimum: 1, maximum: 2 },
-                        invert: { type: "boolean" },
-                        sck_pin: { type: "number", minimum: 0, maximum: 47 },
-                        mosi_pin: { type: "number", minimum: 0, maximum: 47 },
-                        miso_pin: { type: "number", minimum: 0, maximum: 47 },
-                        cs_pin: { type: "number", minimum: 0, maximum: 47 },
-                        mode: { enum: [0, 1, 2, 3] },
-                        cs_active_high: { type: "boolean" },
-                        word_bits: { type: "number", minimum: 1, maximum: 32 },
-                        bit_order: { enum: ["msb", "lsb"] },
-                        sda_pin: { type: "number", minimum: 0, maximum: 47 },
-                        scl_pin: { type: "number", minimum: 0, maximum: 47 },
-                        monitor_root: { type: "string" }
-                    }
-                }
-            },
-            {
-                capability_id: "rp2350.monitor.command",
-                display_name: "RP2350 Monitor Command",
-                description: "Run an allowlisted RP2350-Monitor CLI command over USB CDC or Wi-Fi TCP. Mutating commands require approved=true.",
-                runtime: "local_bridge",
-                category: "board",
-                destructive: true,
-                requires_approval: true,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: rp2350MonitorBaseInputSchema({
-                    command: { type: "string" },
-                    args: { type: "array", items: { type: "string" }, maxItems: 48 }
-                }, ["command"])
-            },
-            {
-                capability_id: "flash.plan",
-                display_name: "Flash Plan",
-                description: "Create a local flash plan for a local image or firmware artifact without allocating a server workspace.",
-                runtime: "local_bridge",
-                category: "flash",
-                destructive: false,
-                requires_approval: false,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["board_id"],
-                    properties: {
-                        board_id: { type: "string" },
-                        variant_id: { type: "string" },
-                        hardware_profile_id: { type: "string" },
-                        profile_id: { type: "string" },
-                        image_dir: { type: "string" },
-                        artifact_path: { type: "string" },
-                        target_volume_path: { type: "string" }
-                    }
-                }
-            },
-            {
-                capability_id: "flash.run",
-                display_name: "Flash Run",
-                description: "Run a local flash job for a local image or firmware artifact after explicit user approval.",
-                runtime: "local_bridge",
-                category: "flash",
-                destructive: true,
-                requires_approval: true,
-                access_tier: "free_registered",
-                free_for_registered_users: true,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: [],
-                status: "available",
-                input_schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["board_id"],
-                    properties: {
-                        board_id: { type: "string" },
-                        variant_id: { type: "string" },
-                        hardware_profile_id: { type: "string" },
-                        profile_id: { type: "string" },
-                        image_dir: { type: "string" },
-                        artifact_path: { type: "string" },
-                        target_volume_path: { type: "string" }
-                    }
-                }
-            },
-            {
-                capability_id: "taishanpi.deploy",
-                display_name: "TaishanPi Deploy",
-                description: "Copy a local artifact to a TaishanPi runtime over SSH and optionally start it.",
-                runtime: "local_bridge",
-                category: "board",
-                destructive: false,
-                requires_approval: true,
-                access_tier: "paid_resource",
-                free_for_registered_users: false,
-                requires_registered_account: true,
-                requires_server_workspace: false,
-                allocates_server_workspace: false,
-                allocates_server_resource_lease: false,
-                meters: ["local_tool_service_tokens"],
-                status: "available",
-                input_schema: {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["host", "artifact_path"],
-                    properties: {
-                        board_id: { const: "taishanpi" },
-                        host: { type: "string" },
-                        user: { type: "string" },
-                        artifact_path: { type: "string" },
-                        remote_path: { type: "string" },
-                        run: { type: "boolean" },
-                        timeout_seconds: { type: "number", minimum: 1 }
-                    }
-                }
-            }
-        ]
-    };
-}
-export async function invokeToolCapability(input) {
-    const parsed = parseToolInvokeRequest(input);
-    if (!parsed.ok) {
-        return parsed;
-    }
-    const observedAt = new Date().toISOString();
-    if (parsed.data.capability_id === "debug.tools.scan") {
-        const inputError = emptyInputError(parsed.data.input, parsed.data.capability_id);
-        if (inputError) {
-            return fail("invalid_request", inputError);
-        }
-        return ok({ capability_id: parsed.data.capability_id, result: await scanDebugTools(), observed_at: observedAt });
-    }
-    if (parsed.data.capability_id === "device.scan") {
-        const inputError = emptyInputError(parsed.data.input, parsed.data.capability_id);
-        if (inputError) {
-            return fail("invalid_request", inputError);
-        }
-        return ok({ capability_id: parsed.data.capability_id, result: await scanHardware(), observed_at: observedAt });
-    }
-    if (parsed.data.capability_id === "device.probe") {
-        const probe = parseDeviceProbeInput(parsed.data.input ?? {});
-        if ("error" in probe) {
-            return fail("invalid_request", probe.error);
-        }
-        return ok({ capability_id: parsed.data.capability_id, result: await probeDevices(probe.request), observed_at: observedAt });
-    }
-    if (parsed.data.capability_id === "wifi.scan") {
-        const live = parseTaishanPiLiveInput(parsed.data.input ?? {}, { interface: true });
-        if ("error" in live) {
-            return fail("invalid_request", live.error);
-        }
-        return ok({ capability_id: parsed.data.capability_id, result: await scanTaishanPiWifiNetworks(live.request), observed_at: observedAt });
-    }
-    if (parsed.data.capability_id === "bluetooth.scan") {
-        const live = parseTaishanPiLiveInput(parsed.data.input ?? {}, { duration_seconds: true });
-        if ("error" in live) {
-            return fail("invalid_request", live.error);
-        }
-        return ok({ capability_id: parsed.data.capability_id, result: await scanTaishanPiBluetoothDevices(live.request), observed_at: observedAt });
-    }
-    if (parsed.data.capability_id === "chip.cpu.frequency") {
-        const live = parseTaishanPiLiveInput(parsed.data.input ?? {});
-        if ("error" in live) {
-            return fail("invalid_request", live.error);
-        }
-        return ok({ capability_id: parsed.data.capability_id, result: await readTaishanPiCpuFrequency(live.request), observed_at: observedAt });
-    }
-    if (parsed.data.capability_id === "chip.temperature") {
-        const live = parseTaishanPiLiveInput(parsed.data.input ?? {});
-        if ("error" in live) {
-            return fail("invalid_request", live.error);
-        }
-        return ok({ capability_id: parsed.data.capability_id, result: await readTaishanPiTemperature(live.request), observed_at: observedAt });
-    }
-    if (parsed.data.capability_id === "qml.runtime.status") {
-        const live = parseTaishanPiLiveInput(parsed.data.input ?? {}, { port: true });
-        if ("error" in live) {
-            return fail("invalid_request", live.error);
-        }
-        return ok({ capability_id: parsed.data.capability_id, result: await getTaishanPiQmlRuntimeStatus(live.request), observed_at: observedAt });
-    }
-    if (parsed.data.capability_id === "qml.runtime.start") {
-        const live = parseTaishanPiLiveInput(parsed.data.input ?? {}, { port: true, force_restart: true });
-        if ("error" in live) {
-            return fail("invalid_request", live.error);
-        }
-        return ok({ capability_id: parsed.data.capability_id, result: await startTaishanPiQmlRuntime(live.request), observed_at: observedAt });
-    }
-    if (parsed.data.capability_id === "rp2350.monitor.status") {
-        const rpmon = parseRp2350MonitorStatusInput(parsed.data.input ?? {});
-        if ("error" in rpmon) {
-            return fail("invalid_request", rpmon.error);
-        }
-        try {
-            return ok({ capability_id: parsed.data.capability_id, result: await getRp2350MonitorStatus(rpmon.request), observed_at: observedAt });
-        }
-        catch (error) {
-            return fail("rp2350_monitor_failed", error instanceof Error ? error.message : String(error));
-        }
-    }
-    if (parsed.data.capability_id === "rp2350.monitor.logic.capture") {
-        const rpmon = parseRp2350MonitorLogicCaptureInput(parsed.data.input ?? {});
-        if ("error" in rpmon) {
-            return fail("invalid_request", rpmon.error);
-        }
-        try {
-            return ok({ capability_id: parsed.data.capability_id, result: await captureRp2350MonitorLogic(rpmon.request), observed_at: observedAt });
-        }
-        catch (error) {
-            return fail("rp2350_monitor_failed", error instanceof Error ? error.message : String(error));
-        }
-    }
-    if (parsed.data.capability_id === "rp2350.monitor.logic.decode") {
-        const rpmon = parseRp2350MonitorLogicDecodeInput(parsed.data.input ?? {});
-        if ("error" in rpmon) {
-            return fail("invalid_request", rpmon.error);
-        }
-        try {
-            return ok({ capability_id: parsed.data.capability_id, result: await decodeRp2350MonitorLogic(rpmon.request), observed_at: observedAt });
-        }
-        catch (error) {
-            return fail("rp2350_monitor_failed", error instanceof Error ? error.message : String(error));
-        }
-    }
-    if (parsed.data.capability_id === "rp2350.monitor.command") {
-        const rpmon = parseRp2350MonitorCommandInput(parsed.data.input ?? {});
-        if ("error" in rpmon) {
-            return fail("invalid_request", rpmon.error);
-        }
-        if (rp2350MonitorCommandNeedsApproval(rpmon.request.command) && parsed.data.approved !== true) {
-            return fail("approval_required", `rp2350.monitor.command ${rpmon.request.command} requires approved=true because it can modify board, bus, Wi-Fi, probe, or GPIO state.`);
-        }
-        try {
-            return ok({ capability_id: parsed.data.capability_id, result: await runRp2350MonitorCommand(rpmon.request), observed_at: observedAt });
-        }
-        catch (error) {
-            return fail("rp2350_monitor_failed", error instanceof Error ? error.message : String(error));
-        }
-    }
-    if (parsed.data.capability_id === "flash.plan") {
-        const flash = parseFlashPlanInput(parsed.data.input ?? {});
-        if ("error" in flash) {
-            return fail("invalid_request", flash.error);
-        }
-        return ok({ capability_id: parsed.data.capability_id, result: await buildFlashPlan(flash.request), observed_at: observedAt });
-    }
-    if (parsed.data.capability_id === "flash.run") {
-        if (parsed.data.approved !== true) {
-            return fail("approval_required", "flash.run requires approved=true because it can write a local image or firmware artifact to a board.");
-        }
-        const flash = parseFlashPlanInput(parsed.data.input ?? {});
-        if ("error" in flash) {
-            return fail("invalid_request", flash.error);
-        }
-        return ok({ capability_id: parsed.data.capability_id, result: await startFlashJob({ ...flash.request, approved: true }), observed_at: observedAt });
-    }
-    if (parsed.data.capability_id === "taishanpi.deploy") {
-        if (parsed.data.approved !== true) {
-            return fail("approval_required", "taishanpi.deploy requires approved=true because it writes to a board over SSH.");
-        }
-        const deploy = validateTaishanPiDeployRequest(parsed.data.input ?? {});
-        if ("error" in deploy) {
-            return fail("invalid_request", deploy.error);
-        }
-        const deployed = await deployTaishanPiApplication(deploy.request);
-        if ("ok" in deployed && deployed.ok === false) {
-            return deployed;
-        }
-        return ok({ capability_id: parsed.data.capability_id, result: deployed, observed_at: observedAt });
-    }
-    return fail("tool_capability_not_found", `No local tool capability found for ${parsed.data.capability_id}.`);
-}
-function emptyInputError(input, capabilityId) {
-    if (input === undefined || Object.keys(input).length === 0) {
-        return undefined;
-    }
-    return `${capabilityId} does not accept input fields: ${Object.keys(input).join(", ")}.`;
-}
-function taishanPiLiveInputSchema(extraProperties = {}) {
-    return {
-        type: "object",
-        additionalProperties: false,
-        properties: {
-            board_id: { const: "taishanpi" },
-            variant_id: { type: "string" },
-            host: { type: "string" },
-            user: { type: "string" },
-            timeout_seconds: { type: "number", minimum: 3, maximum: 60 },
-            ...extraProperties
-        }
-    };
-}
-function rp2350MonitorBaseInputSchema(extraProperties = {}, required = []) {
-    return {
-        type: "object",
-        additionalProperties: false,
-        required,
-        properties: {
-            transport: { enum: ["auto", "serial", "tcp"] },
-            serial_path: { type: "string" },
-            host: { type: "string" },
-            port: { type: "number", minimum: 1, maximum: 65535 },
-            baud: { type: "number", minimum: 300, maximum: 4000000 },
-            timeout_ms: { type: "number", minimum: 100, maximum: 120000 },
-            monitor_root: { type: "string" },
-            ...extraProperties
-        }
-    };
-}
-function parseRp2350MonitorStatusInput(input) {
-    const base = parseRp2350MonitorBaseInput(input, RP2350_MONITOR_STATUS_FIELDS);
-    if ("error" in base) {
-        return base;
-    }
-    const body = input;
-    if (body.include_caps !== undefined && typeof body.include_caps !== "boolean") {
-        return { error: "include_caps must be a boolean when provided." };
-    }
-    return { request: { ...base.request, include_caps: typeof body.include_caps === "boolean" ? body.include_caps : undefined } };
-}
-function parseRp2350MonitorCommandInput(input) {
-    const base = parseRp2350MonitorBaseInput(input, RP2350_MONITOR_COMMAND_FIELDS);
-    if ("error" in base) {
-        return base;
-    }
-    const body = input;
-    const command = optionalString(body.command);
-    if (!command) {
-        return { error: "command is required." };
-    }
-    let args;
-    if (body.args !== undefined) {
-        if (!Array.isArray(body.args)) {
-            return { error: "args must be an array of strings." };
-        }
-        const invalid = body.args.find((item) => typeof item !== "string" || item.length > 512);
-        if (invalid !== undefined) {
-            return { error: "args must contain strings up to 512 characters." };
-        }
-        if (body.args.length > 48) {
-            return { error: "args may contain at most 48 items." };
-        }
-        args = body.args.map((item) => item.trim()).filter(Boolean);
-    }
-    return { request: { ...base.request, command, args } };
-}
-function parseRp2350MonitorLogicCaptureInput(input) {
-    const base = parseRp2350MonitorBaseInput(input, RP2350_MONITOR_LOGIC_CAPTURE_FIELDS);
-    if ("error" in base) {
-        return base;
-    }
-    const body = input;
-    const pinBase = requiredNumber(body.pin_base, "pin_base", 0, 47);
-    if ("error" in pinBase) {
-        return pinBase;
-    }
-    const pinCount = requiredNumber(body.pin_count, "pin_count", 1, 16);
-    if ("error" in pinCount) {
-        return pinCount;
-    }
-    const sampleRate = optionalNumber(body.sample_rate, "sample_rate", 1, 125_000_000);
-    if ("error" in sampleRate) {
-        return sampleRate;
-    }
-    const samples = optionalNumber(body.samples, "samples", 1, 1_048_576);
-    if ("error" in samples) {
-        return samples;
-    }
-    const waitTimeout = optionalNumber(body.wait_timeout_ms, "wait_timeout_ms", 1000, 120_000);
-    if ("error" in waitTimeout) {
-        return waitTimeout;
-    }
-    const readTimeout = optionalNumber(body.read_timeout_ms, "read_timeout_ms", 1000, 120_000);
-    if ("error" in readTimeout) {
-        return readTimeout;
-    }
-    const preSamples = optionalNumber(body.pre_samples, "pre_samples", 0, 1_048_576);
-    if ("error" in preSamples) {
-        return preSamples;
-    }
-    const postSamples = optionalNumber(body.post_samples, "post_samples", 0, 1_048_576);
-    if ("error" in postSamples) {
-        return postSamples;
-    }
-    const searchSamples = optionalNumber(body.search_samples, "search_samples", 0, 1_048_576);
-    if ("error" in searchSamples) {
-        return searchSamples;
-    }
-    const burstCount = optionalNumber(body.burst_count, "burst_count", 1, 32);
-    if ("error" in burstCount) {
-        return burstCount;
-    }
-    const triggerPin = optionalNumber(body.trigger_pin, "trigger_pin", 0, 47);
-    if ("error" in triggerPin) {
-        return triggerPin;
-    }
-    const triggerMask = optionalNumber(body.trigger_mask, "trigger_mask", 0, 0xffff_ffff);
-    if ("error" in triggerMask) {
-        return triggerMask;
-    }
-    const triggerValue = optionalNumber(body.trigger_value, "trigger_value", 0, 0xffff_ffff);
-    if ("error" in triggerValue) {
-        return triggerValue;
-    }
-    const pull = optionalEnum(body.pull, "pull", ["none", "up", "down"]);
-    if ("error" in pull) {
-        return pull;
-    }
-    const triggerMode = optionalEnum(body.trigger_mode, "trigger_mode", ["level", "rising", "falling", "pattern"]);
-    if ("error" in triggerMode) {
-        return triggerMode;
-    }
-    const channelNames = optionalStringMap(body.channel_names, "channel_names");
-    if ("error" in channelNames) {
-        return channelNames;
-    }
-    const pinPulls = optionalPullMap(body.pin_pulls, "pin_pulls");
-    if ("error" in pinPulls) {
-        return pinPulls;
-    }
-    if (body.release !== undefined && typeof body.release !== "boolean") {
-        return { error: "release must be a boolean when provided." };
-    }
-    if (body.trigger_level !== undefined && typeof body.trigger_level !== "boolean") {
-        return { error: "trigger_level must be a boolean when provided." };
-    }
-    return {
-        request: {
-            ...base.request,
-            pin_base: pinBase.value,
-            pin_count: pinCount.value,
-            sample_rate: sampleRate.value,
-            samples: samples.value,
-            output_path: optionalString(body.output_path),
-            pull: pull.value,
-            release: typeof body.release === "boolean" ? body.release : undefined,
-            wait_timeout_ms: waitTimeout.value,
-            read_timeout_ms: readTimeout.value,
-            pre_samples: preSamples.value,
-            post_samples: postSamples.value,
-            search_samples: searchSamples.value,
-            burst_count: burstCount.value,
-            trigger_pin: triggerPin.value,
-            trigger_mode: triggerMode.value,
-            trigger_level: typeof body.trigger_level === "boolean" ? body.trigger_level : undefined,
-            trigger_mask: triggerMask.value,
-            trigger_value: triggerValue.value,
-            channel_names: channelNames.value,
-            pin_pulls: pinPulls.value
-        }
-    };
-}
-function parseRp2350MonitorLogicDecodeInput(input) {
-    if (!input || typeof input !== "object" || Array.isArray(input)) {
-        return { error: "input must be a JSON object." };
-    }
-    const body = input;
-    const unknownFields = Object.keys(body).filter((field) => !RP2350_MONITOR_LOGIC_DECODE_FIELDS.has(field));
-    if (unknownFields.length > 0) {
-        return { error: `Unsupported RP2350 Monitor logic decode field(s): ${unknownFields.join(", ")}.` };
-    }
-    const inputPath = optionalString(body.input_path);
-    if (!inputPath) {
-        return { error: "input_path is required." };
-    }
-    const decoder = optionalEnum(body.decoder, "decoder", ["summary", "bursts", "edges", "uart", "spi", "i2c"]);
-    if ("error" in decoder) {
-        return decoder;
-    }
-    const pins = optionalNumberArray(body.pins, "pins", 0, 47);
-    if ("error" in pins) {
-        return pins;
-    }
-    const captureId = optionalNumber(body.capture_id, "capture_id", 0, 1_000_000);
-    if ("error" in captureId) {
-        return captureId;
-    }
-    const startSample = optionalNumber(body.start_sample, "start_sample", 0, 1_000_000_000);
-    if ("error" in startSample) {
-        return startSample;
-    }
-    const endSample = optionalNumber(body.end_sample, "end_sample", 0, 1_000_000_000);
-    if ("error" in endSample) {
-        return endSample;
-    }
-    const rxPin = optionalNumber(body.rx_pin, "rx_pin", 0, 47);
-    if ("error" in rxPin) {
-        return rxPin;
-    }
-    const baud = optionalNumber(body.baud, "baud", 1, 20_000_000);
-    if ("error" in baud) {
-        return baud;
-    }
-    const dataBits = optionalNumber(body.data_bits, "data_bits", 5, 9);
-    if ("error" in dataBits) {
-        return dataBits;
-    }
-    const parity = optionalEnum(body.parity, "parity", ["none", "even", "odd"]);
-    if ("error" in parity) {
-        return parity;
-    }
-    const sckPin = optionalNumber(body.sck_pin, "sck_pin", 0, 47);
-    if ("error" in sckPin) {
-        return sckPin;
-    }
-    const mosiPin = optionalNumber(body.mosi_pin, "mosi_pin", 0, 47);
-    if ("error" in mosiPin) {
-        return mosiPin;
-    }
-    const misoPin = optionalNumber(body.miso_pin, "miso_pin", 0, 47);
-    if ("error" in misoPin) {
-        return misoPin;
-    }
-    const csPin = optionalNumber(body.cs_pin, "cs_pin", 0, 47);
-    if ("error" in csPin) {
-        return csPin;
-    }
-    const mode = optionalNumber(body.mode, "mode", 0, 3);
-    if ("error" in mode) {
-        return mode;
-    }
-    const wordBits = optionalNumber(body.word_bits, "word_bits", 1, 32);
-    if ("error" in wordBits) {
-        return wordBits;
-    }
-    const bitOrder = optionalEnum(body.bit_order, "bit_order", ["msb", "lsb"]);
-    if ("error" in bitOrder) {
-        return bitOrder;
-    }
-    const sdaPin = optionalNumber(body.sda_pin, "sda_pin", 0, 47);
-    if ("error" in sdaPin) {
-        return sdaPin;
-    }
-    const sclPin = optionalNumber(body.scl_pin, "scl_pin", 0, 47);
-    if ("error" in sclPin) {
-        return sclPin;
-    }
-    if (body.stop_bits !== undefined && (typeof body.stop_bits !== "number" || ![1, 1.5, 2].includes(body.stop_bits))) {
-        return { error: "stop_bits must be 1, 1.5, or 2 when provided." };
-    }
-    if (body.invert !== undefined && typeof body.invert !== "boolean") {
-        return { error: "invert must be a boolean when provided." };
-    }
-    if (body.cs_active_high !== undefined && typeof body.cs_active_high !== "boolean") {
-        return { error: "cs_active_high must be a boolean when provided." };
-    }
-    return {
-        request: {
-            input_path: inputPath,
-            decoder: decoder.value,
-            output_path: optionalString(body.output_path),
-            capture_id: captureId.value,
-            start_sample: startSample.value,
-            end_sample: endSample.value,
-            pins: pins.value,
-            rx_pin: rxPin.value,
-            baud: baud.value,
-            data_bits: dataBits.value,
-            parity: parity.value,
-            stop_bits: typeof body.stop_bits === "number" ? body.stop_bits : undefined,
-            invert: typeof body.invert === "boolean" ? body.invert : undefined,
-            sck_pin: sckPin.value,
-            mosi_pin: mosiPin.value,
-            miso_pin: misoPin.value,
-            cs_pin: csPin.value,
-            mode: mode.value,
-            cs_active_high: typeof body.cs_active_high === "boolean" ? body.cs_active_high : undefined,
-            word_bits: wordBits.value,
-            bit_order: bitOrder.value,
-            sda_pin: sdaPin.value,
-            scl_pin: sclPin.value,
-            monitor_root: optionalString(body.monitor_root)
-        }
-    };
-}
-function parseRp2350MonitorBaseInput(input, allowedFields) {
-    if (!input || typeof input !== "object" || Array.isArray(input)) {
-        return { error: "input must be a JSON object." };
-    }
-    const body = input;
-    const unknownFields = Object.keys(body).filter((field) => !allowedFields.has(field));
-    if (unknownFields.length > 0) {
-        return { error: `Unsupported RP2350 Monitor field(s): ${unknownFields.join(", ")}.` };
-    }
-    const transport = optionalEnum(body.transport, "transport", ["auto", "serial", "tcp"]);
-    if ("error" in transport) {
-        return transport;
-    }
-    const host = optionalString(body.host);
-    if (body.host !== undefined && (!host || !isValidProbeHost(host))) {
-        return { error: "host must be a hostname or IP address without schemes, paths, spaces, or credentials." };
-    }
-    const port = optionalNumber(body.port, "port", 1, 65_535);
-    if ("error" in port) {
-        return port;
-    }
-    const baud = optionalNumber(body.baud, "baud", 300, 4_000_000);
-    if ("error" in baud) {
-        return baud;
-    }
-    const timeoutMs = optionalNumber(body.timeout_ms, "timeout_ms", 100, 120_000);
-    if ("error" in timeoutMs) {
-        return timeoutMs;
-    }
-    const serialPath = optionalString(body.serial_path);
-    if (body.serial_path !== undefined && !serialPath) {
-        return { error: "serial_path must be a non-empty string when provided." };
-    }
-    if (transport.value === "serial" && !serialPath) {
-        return { error: "serial_path is required when transport=serial." };
-    }
-    return {
-        request: {
-            transport: transport.value,
-            serial_path: serialPath,
-            host,
-            port: port.value,
-            baud: baud.value,
-            timeout_ms: timeoutMs.value,
-            monitor_root: optionalString(body.monitor_root)
-        }
-    };
-}
-function parseToolInvokeRequest(input) {
-    if (!input || typeof input !== "object" || Array.isArray(input)) {
-        return fail("invalid_request", "Request body must be a JSON object.");
-    }
-    const body = input;
-    const unknownFields = Object.keys(body).filter((field) => !["capability_id", "input", "approved"].includes(field));
-    if (unknownFields.length > 0) {
-        return fail("invalid_request", `Unsupported field(s): ${unknownFields.join(", ")}.`);
-    }
-    if (typeof body.capability_id !== "string" || !body.capability_id.trim()) {
-        return fail("invalid_request", "capability_id is required.");
-    }
-    if (body.input !== undefined && (!body.input || typeof body.input !== "object" || Array.isArray(body.input))) {
-        return fail("invalid_request", "input must be a JSON object when provided.");
-    }
-    if (body.approved !== undefined && typeof body.approved !== "boolean") {
-        return fail("invalid_request", "approved must be a boolean when provided.");
-    }
-    return ok({
-        capability_id: body.capability_id.trim(),
-        input: body.input,
-        approved: body.approved
-    });
-}
-function parseDeviceProbeInput(input) {
-    if (!input || typeof input !== "object" || Array.isArray(input)) {
-        return { error: "input must be a JSON object." };
-    }
-    const request = input;
-    const unknownFields = Object.keys(request).filter((field) => !PROBE_REQUEST_FIELDS.has(field));
-    if (unknownFields.length > 0) {
-        return { error: `Unsupported field(s): ${unknownFields.join(", ")}.` };
-    }
-    let host;
-    if (request.host !== undefined) {
-        if (typeof request.host !== "string") {
-            return { error: "host must be a hostname or IP address string." };
-        }
-        host = request.host.trim();
-        if (!isValidProbeHost(host)) {
-            return { error: "host must be a hostname or IP address without schemes, paths, spaces, or credentials." };
-        }
-    }
-    let ports;
-    if (request.ports !== undefined) {
-        if (!Array.isArray(request.ports)) {
-            return { error: "ports must be an array." };
-        }
-        const invalidPort = request.ports.find((port) => typeof port !== "number" || !Number.isInteger(port) || port < 1 || port > 65_535);
-        if (invalidPort !== undefined) {
-            return { error: `Invalid TCP port: ${String(invalidPort)}.` };
-        }
-        ports = [...request.ports];
-    }
-    let serialPaths;
-    if (request.serial_paths !== undefined) {
-        if (!Array.isArray(request.serial_paths)) {
-            return { error: "serial_paths must be an array." };
-        }
-        const invalidPath = request.serial_paths.find((path) => typeof path !== "string" || !path.trim());
-        if (invalidPath !== undefined) {
-            return { error: "serial_paths must contain non-empty strings." };
-        }
-        serialPaths = request.serial_paths.map((path) => path.trim());
-    }
-    if (request.timeout_ms !== undefined && (typeof request.timeout_ms !== "number" || !Number.isFinite(request.timeout_ms) || request.timeout_ms <= 0)) {
-        return { error: "timeout_ms must be a positive number." };
-    }
-    const hasPorts = (ports?.length ?? 0) > 0;
-    const hasSerialPaths = (serialPaths?.length ?? 0) > 0;
-    if (!hasPorts && !hasSerialPaths) {
-        return { error: "At least one TCP port or serial path is required." };
-    }
-    if (hasPorts && !host) {
-        return { error: "host is required when ports are provided." };
-    }
-    return {
-        request: {
-            host,
-            ports,
-            serial_paths: serialPaths,
-            timeout_ms: typeof request.timeout_ms === "number" ? request.timeout_ms : undefined
-        }
-    };
-}
-function parseTaishanPiLiveInput(input, allowed = {}) {
-    if (!input || typeof input !== "object" || Array.isArray(input)) {
-        return { error: "input must be a JSON object." };
-    }
-    const body = input;
-    const allowedFields = new Set(["board_id", "variant_id", "host", "user", "timeout_seconds"]);
-    if (allowed.interface) {
-        allowedFields.add("interface");
-    }
-    if (allowed.duration_seconds) {
-        allowedFields.add("duration_seconds");
-    }
-    if (allowed.port) {
-        allowedFields.add("port");
-    }
-    if (allowed.force_restart) {
-        allowedFields.add("force_restart");
-    }
-    const unknownFields = Object.keys(body).filter((field) => !TAISHANPI_LIVE_FIELDS.has(field) || !allowedFields.has(field));
-    if (unknownFields.length > 0) {
-        return { error: `Unsupported TaishanPi live-probe field(s): ${unknownFields.join(", ")}.` };
-    }
-    if (body.board_id !== undefined && body.board_id !== "taishanpi") {
-        return { error: "board_id must be taishanpi when provided." };
-    }
-    if (body.variant_id !== undefined && (typeof body.variant_id !== "string" || !body.variant_id.trim())) {
-        return { error: "variant_id must be a non-empty string when provided." };
-    }
-    const host = optionalString(body.host);
-    if (body.host !== undefined && (!host || !isValidProbeHost(host))) {
-        return { error: "host must be a hostname or IP address without schemes, paths, spaces, or credentials." };
-    }
-    const user = optionalString(body.user);
-    if (body.user !== undefined && (!user || !/^[A-Za-z0-9._-]{1,64}$/.test(user))) {
-        return { error: "user must contain only letters, numbers, dots, underscores, or hyphens." };
-    }
-    const timeoutSeconds = optionalNumber(body.timeout_seconds, "timeout_seconds", 3, 60);
-    if ("error" in timeoutSeconds) {
-        return timeoutSeconds;
-    }
-    const liveInterface = optionalString(body.interface);
-    if (body.interface !== undefined && (!liveInterface || !/^[A-Za-z0-9_.:-]{1,64}$/.test(liveInterface))) {
-        return { error: "interface must be a safe network interface name." };
-    }
-    const durationSeconds = optionalNumber(body.duration_seconds, "duration_seconds", 3, 30);
-    if ("error" in durationSeconds) {
-        return durationSeconds;
-    }
-    const port = optionalNumber(body.port, "port", 1, 65_535);
-    if ("error" in port) {
-        return port;
-    }
-    if (body.force_restart !== undefined && typeof body.force_restart !== "boolean") {
-        return { error: "force_restart must be a boolean when provided." };
-    }
-    return {
-        request: {
-            board_id: "taishanpi",
-            variant_id: optionalString(body.variant_id),
-            host,
-            user,
-            timeout_seconds: timeoutSeconds.value,
-            interface: liveInterface,
-            duration_seconds: durationSeconds.value,
-            port: port.value,
-            force_restart: typeof body.force_restart === "boolean" ? body.force_restart : undefined
-        }
-    };
-}
-function parseFlashPlanInput(input) {
-    if (!input || typeof input !== "object" || Array.isArray(input)) {
-        return { error: "input must be a JSON object." };
-    }
-    const body = input;
-    const unknownFields = Object.keys(body).filter((field) => !FLASH_REQUEST_FIELDS.has(field));
-    if (unknownFields.length > 0) {
-        return { error: `Unsupported flash field(s): ${unknownFields.join(", ")}.` };
-    }
-    if (typeof body.board_id !== "string" || !body.board_id.trim()) {
-        return { error: "board_id is required." };
-    }
-    return {
-        request: {
-            board_id: body.board_id.trim(),
-            variant_id: optionalString(body.variant_id),
-            hardware_profile_id: optionalString(body.hardware_profile_id),
-            profile_id: optionalString(body.profile_id),
-            image_dir: optionalString(body.image_dir),
-            artifact_path: optionalString(body.artifact_path),
-            target_volume_path: optionalString(body.target_volume_path)
-        }
-    };
-}
-function requiredNumber(value, label, min, max) {
-    const parsed = optionalNumber(value, label, min, max);
-    if ("error" in parsed) {
-        return parsed;
-    }
-    if (parsed.value === undefined) {
-        return { error: `${label} is required.` };
-    }
-    return { value: parsed.value };
-}
-function optionalEnum(value, label, allowed) {
-    if (value === undefined) {
-        return {};
-    }
-    if (typeof value !== "string" || !allowed.includes(value)) {
-        return { error: `${label} must be one of ${allowed.join(", ")}.` };
-    }
-    return { value: value };
-}
-function optionalNumberArray(value, label, min, max) {
-    if (value === undefined) {
-        return {};
-    }
-    if (!Array.isArray(value)) {
-        return { error: `${label} must be an array of numbers.` };
-    }
-    const parsed = [];
-    for (const item of value) {
-        const numberValue = optionalNumber(item, label, min, max);
-        if ("error" in numberValue || numberValue.value === undefined) {
-            return { error: `${label} must contain numbers from ${min} through ${max}.` };
-        }
-        parsed.push(numberValue.value);
-    }
-    return { value: parsed };
-}
-function optionalStringMap(value, label) {
-    if (value === undefined) {
-        return {};
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return { error: `${label} must be an object when provided.` };
-    }
-    const output = {};
-    for (const [key, item] of Object.entries(value)) {
-        if (!/^\d{1,2}$/.test(key) || typeof item !== "string" || !item.trim()) {
-            return { error: `${label} must map GPIO numbers to non-empty strings.` };
-        }
-        output[key] = item.trim();
-    }
-    return { value: output };
-}
-function optionalPullMap(value, label) {
-    if (value === undefined) {
-        return {};
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return { error: `${label} must be an object when provided.` };
-    }
-    const output = {};
-    for (const [key, item] of Object.entries(value)) {
-        if (!/^\d{1,2}$/.test(key) || typeof item !== "string" || !["none", "up", "down"].includes(item)) {
-            return { error: `${label} must map GPIO numbers to none, up, or down.` };
-        }
-        output[key] = item;
-    }
-    return { value: output };
-}
-function optionalString(value) {
-    return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
-function optionalNumber(value, label, min, max) {
-    if (value === undefined) {
-        return {};
-    }
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-        return { error: `${label} must be a number when provided.` };
-    }
-    const normalized = Math.trunc(value);
-    if (normalized < min || normalized > max) {
-        return { error: `${label} must be from ${min} through ${max}.` };
-    }
-    return { value: normalized };
-}
-function isValidProbeHost(host) {
-    if (!host || host.length > 253 || /[\s\x00-\x1f\x7f]/.test(host)) {
-        return false;
-    }
-    if (host.includes("://") || host.includes("/") || host.includes("\\") || host.includes("@")) {
-        return false;
-    }
-    if (net.isIP(host) !== 0) {
-        return true;
-    }
-    return host.split(".").every((label) => /^[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/.test(label));
-}
-//# sourceMappingURL=tools.js.map