@easynet-run/node 0.27.14

package/src/presets/ability_dispatch.d.ts

@@ -0,0 +1 @@
+export { type ModeSpec, type AbilityDispatchConfig, MEDIA_CAPTURE_MODE_SPECS, validateMediaCaptureResult, mediaCaptureMetadataBuilder, mediaCaptureTaskPayload, runCaseFromArgs, runCase, } from "./ability_dispatch/workflow.js";

package/src/presets/ability_dispatch.js

@@ -0,0 +1,2 @@
+// Barrel re-export for the ability-dispatch case module.
+export { MEDIA_CAPTURE_MODE_SPECS, validateMediaCaptureResult, mediaCaptureMetadataBuilder, mediaCaptureTaskPayload, runCaseFromArgs, runCase, } from "./ability_dispatch/workflow.js";

package/src/presets/remote_control/config.d.ts

@@ -0,0 +1,16 @@
+export interface RemoteControlRuntimeConfig {
+    endpoint: string;
+    tenant: string;
+    connectTimeoutMs: number;
+    signatureBase64: string;
+}
+export declare const DEFAULT_SIGNATURE = "__AXON_EPHEMERAL_DO_NOT_USE_IN_PROD__";
+export declare const DEFAULT_VERSION = "1.0.0";
+export declare const DEFAULT_INSTALL_TIMEOUT_SECONDS = 45;
+export declare const DEFAULT_EXECUTION_MODE = "sandbox_first";
+export declare function loadRemoteControlConfigFromEnv(): RemoteControlRuntimeConfig;
+export declare function loadConfigFromEnv(): RemoteControlRuntimeConfig;
+export declare function ensureRemoteControlNativeLibEnv(): void;
+export declare function ensureNativeLibEnv(): void;
+export declare function parsePositiveInt(raw: string | undefined, fallback: number): number;
+export declare function asString(raw: unknown, fallback?: string): string;

package/src/presets/remote_control/config.js

@@ -0,0 +1,63 @@
+// EasyNet Axon for AgentNet
+// =========================
+//
+// File: sdk/node/src/presets/remote_control/config.js
+// Description: AUTO-GENERATED — compiled from config.ts. Runtime configuration for the remote-control preset.
+//
+// Author: Silan.Hu
+// Email: silan.hu@u.nus.edu
+// Copyright (c) 2026-2027 easynet. All rights reserved.
+
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export const DEFAULT_SIGNATURE = "__AXON_EPHEMERAL_DO_NOT_USE_IN_PROD__";
+export const DEFAULT_VERSION = "1.0.0";
+export const DEFAULT_INSTALL_TIMEOUT_SECONDS = 45;
+export const DEFAULT_EXECUTION_MODE = "sandbox_first";
+export function loadRemoteControlConfigFromEnv() {
+    return {
+        endpoint: process.env.AXON_ENDPOINT ?? "http://127.0.0.1:50051",
+        tenant: process.env.AXON_TENANT ?? "tenant-test",
+        connectTimeoutMs: parsePositiveInt(process.env.AXON_CONNECT_TIMEOUT_MS, 5000),
+        signatureBase64: process.env.AXON_DEPLOY_SIGNATURE_BASE64 ?? DEFAULT_SIGNATURE,
+    };
+}
+export function loadConfigFromEnv() {
+    return loadRemoteControlConfigFromEnv();
+}
+export function ensureRemoteControlNativeLibEnv() {
+    if (process.env.EASYNET_DENDRITE_BRIDGE_LIB) {
+        return;
+    }
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        resolve(moduleDir, "..", "..", "core", "runtime-rs", "dendrite-bridge", "target", "release", defaultNativeLibName()),
+        resolve(moduleDir, "..", "..", "core", "runtime-rs", "dendrite-bridge", "target", "debug", defaultNativeLibName()),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            process.env.EASYNET_DENDRITE_BRIDGE_LIB = candidate;
+            return;
+        }
+    }
+}
+export function ensureNativeLibEnv() {
+    ensureRemoteControlNativeLibEnv();
+}
+export function parsePositiveInt(raw, fallback) {
+    const parsed = Number.parseInt((raw ?? "").trim(), 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+export function asString(raw, fallback = "") {
+    return raw == null ? fallback : String(raw).trim() || fallback;
+}
+function defaultNativeLibName() {
+    if (process.platform === "darwin") {
+        return "libaxon_dendrite_bridge.dylib";
+    }
+    if (process.platform === "win32") {
+        return "axon_dendrite_bridge.dll";
+    }
+    return "libaxon_dendrite_bridge.so";
+}

package/src/presets/remote_control/descriptor.d.ts

@@ -0,0 +1,34 @@
+export interface JsonRecord {
+    [key: string]: unknown;
+}
+export interface AbilityPackageDescriptor {
+    abilityName: string;
+    packageId: string;
+    capabilityName: string;
+    toolName: string;
+    description: string;
+    version: string;
+    tags: string[];
+    metadata: Record<string, string>;
+    signatureBase64: string;
+    packageBytesBase64: string;
+    digest?: string;
+}
+export declare function resolveTenant(raw: unknown, fallback: string): string;
+export declare function parseBool(raw: unknown): boolean;
+export declare function randomSuffix(length?: number): string;
+export declare function sanitizeId(raw: string): string;
+export declare function shellSingleQuote(raw: string): string;
+/**
+ * Wraps a shell command in a `python3 -c` subprocess template that returns
+ * structured JSON output with `entries`, `stdout`, `stderr`, and `exit_code`.
+ */
+export declare function buildPythonSubprocessTemplate(command: string): string;
+export declare function asStringArray(raw: unknown): string[];
+export declare function normalizeTags(tags: unknown, fallback: string[]): string[];
+export declare function defaultInputSchema(): JsonRecord;
+export declare function defaultOutputSchema(): JsonRecord;
+export declare function serializeDescriptor(descriptor: AbilityPackageDescriptor): JsonRecord;
+export declare function requireString(payload: JsonRecord, key: string): string;
+export declare function parseDescriptor(raw: unknown): AbilityPackageDescriptor;
+export declare function buildDescriptor(args: JsonRecord, defaultSignature: string): AbilityPackageDescriptor;

package/src/presets/remote_control/descriptor.js

@@ -0,0 +1,183 @@
+import { DEFAULT_VERSION, asString } from "./config.js";
+export function resolveTenant(raw, fallback) {
+    const value = asString(raw);
+    return !value || value === "<nil>" ? fallback : value;
+}
+export function parseBool(raw) {
+    if (typeof raw === "boolean") {
+        return raw;
+    }
+    if (typeof raw === "number") {
+        return raw !== 0;
+    }
+    const normalized = asString(raw).toLowerCase();
+    return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on";
+}
+export function randomSuffix(length = 2) {
+    return Math.floor(Math.random() * 1e18).toString(36).slice(0, length);
+}
+export function sanitizeId(raw) {
+    const token = asString(raw).toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+    return token || "tool";
+}
+export function shellSingleQuote(raw) {
+    return `'${raw.replace(/'/g, "'\"'\"'")}'`;
+}
+/**
+ * Wraps a shell command in a `python3 -c` subprocess template that returns
+ * structured JSON output with `entries`, `stdout`, `stderr`, and `exit_code`.
+ */
+export function buildPythonSubprocessTemplate(command) {
+    const quoted = JSON.stringify(command);
+    const script = [
+        "import json,subprocess",
+        `cmd = ${quoted}`,
+        "proc = subprocess.run(['/bin/sh', '-c', cmd], text=True, capture_output=True)",
+        "combined = (proc.stdout + proc.stderr).strip()",
+        "print(json.dumps({'entries': [combined], 'command': cmd, 'exit_code': proc.returncode, 'stdout': proc.stdout, 'stderr': proc.stderr}))",
+    ].join("; ");
+    return `python3 -c ${shellSingleQuote(script)}`;
+}
+export function asStringArray(raw) {
+    return Array.isArray(raw) ? raw.map((value) => asString(value)) : [];
+}
+export function normalizeTags(tags, fallback) {
+    const result = [];
+    const seen = new Set();
+    const all = [...fallback, ...asStringArray(tags)];
+    for (const tag of all) {
+        const value = tag.trim();
+        if (!value || seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        result.push(value);
+    }
+    return result;
+}
+export function defaultInputSchema() {
+    return { type: "object", properties: { entries: { type: "array", items: { type: "string" } } } };
+}
+export function defaultOutputSchema() {
+    return {
+        type: "object",
+        properties: {
+            entries: { type: "array", items: { type: "string" } },
+        },
+        required: ["entries"],
+    };
+}
+export function serializeDescriptor(descriptor) {
+    const payload = {
+        "ability_name": descriptor.abilityName,
+        "package_id": descriptor.packageId,
+        "capability_name": descriptor.capabilityName,
+        "tool_name": descriptor.toolName,
+        "description": descriptor.description,
+        "version": descriptor.version,
+        "tags": descriptor.tags,
+        "metadata": descriptor.metadata,
+        "signature_base64": descriptor.signatureBase64,
+        "package_bytes_base64": descriptor.packageBytesBase64,
+    };
+    if (descriptor.digest) {
+        payload.digest = descriptor.digest;
+    }
+    return payload;
+}
+export function requireString(payload, key) {
+    const value = asString(payload[key]);
+    if (!value) {
+        throw new Error(`${key} is required`);
+    }
+    return value;
+}
+export function parseDescriptor(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new Error("package must be an object");
+    }
+    const input = raw;
+    const metadataRaw = input.metadata;
+    if (!metadataRaw || typeof metadataRaw !== "object" || Array.isArray(metadataRaw)) {
+        throw new Error("package.metadata must be an object of string values");
+    }
+    const metadata = {};
+    for (const [k, v] of Object.entries(metadataRaw)) {
+        metadata[k] = asString(v);
+    }
+    const required = ["ability_name", "package_id", "capability_name", "tool_name", "description", "version", "signature_base64", "package_bytes_base64"];
+    for (const key of required) {
+        if (!asString(input[key])) {
+            throw new Error(`package.${key} is required`);
+        }
+    }
+    return {
+        abilityName: asString(input.ability_name),
+        packageId: asString(input.package_id),
+        capabilityName: asString(input.capability_name),
+        toolName: asString(input.tool_name),
+        description: asString(input.description),
+        version: asString(input.version),
+        tags: normalizeTags(input.tags, ["mcp", "ability", "gallery"]),
+        metadata,
+        signatureBase64: asString(input.signature_base64),
+        packageBytesBase64: asString(input.package_bytes_base64),
+        digest: asString(input.digest) || undefined,
+    };
+}
+export function buildDescriptor(args, defaultSignature) {
+    const abilityName = requireString(args, "ability_name");
+    const commandTemplate = requireString(args, "command_template");
+    const now = Date.now();
+    const token = sanitizeId(abilityName);
+    const version = asString(args.version, DEFAULT_VERSION);
+    const toolName = asString(args.tool_name, `ability_${token}`);
+    const packageId = asString(args.package_id, `pkg.ability.${token}.${now}`);
+    const capabilityName = asString(args.capability_name, `ability_${token}`);
+    const description = asString(args.description, `Ability ${abilityName}`);
+    const signatureBase64 = asString(args.signature_base64, defaultSignature);
+    if (!signatureBase64) {
+        throw new Error("signature_base64 is required");
+    }
+    const inputSchema = typeof args.input_schema === "object" && !Array.isArray(args.input_schema)
+        ? args.input_schema
+        : defaultInputSchema();
+    const outputSchema = typeof args.output_schema === "object" && !Array.isArray(args.output_schema)
+        ? args.output_schema
+        : defaultOutputSchema();
+    const metadata = {
+        "mcp.tool_name": toolName,
+        "mcp.description": description,
+        "mcp.input_schema": JSON.stringify(inputSchema),
+        "mcp.output_schema": JSON.stringify(outputSchema),
+        "axon.exec.command": commandTemplate,
+        "ability.name": abilityName,
+        "ability.version": version,
+    };
+    const payload = {
+        kind: "axon.ability.package.v1",
+        ability_name: abilityName,
+        package_id: packageId,
+        capability_name: capabilityName,
+        tool_name: toolName,
+        description,
+        version,
+        command_template: commandTemplate,
+        input_schema: inputSchema,
+        output_schema: outputSchema,
+        created_at_unix_ms: now,
+    };
+    return {
+        abilityName,
+        packageId,
+        capabilityName,
+        toolName,
+        description,
+        version,
+        tags: normalizeTags(args.tags, ["mcp", "ability", "gallery"]),
+        metadata,
+        signatureBase64,
+        packageBytesBase64: Buffer.from(JSON.stringify(payload), "utf8").toString("base64"),
+        digest: asString(args.digest) || undefined,
+    };
+}

package/src/presets/remote_control/handlers.d.ts

@@ -0,0 +1,12 @@
+import type { JsonRecord, RemoteOrchestrator } from "./orchestrator.js";
+import { type AbilityPackageDescriptor } from "./descriptor.js";
+export declare function resolveDescriptor(args: JsonRecord, fallbackSignature: string): AbilityPackageDescriptor;
+export declare function handleDiscoverNodes(orch: RemoteOrchestrator, tenant: string): JsonRecord;
+export declare function handleListRemoteTools(orch: RemoteOrchestrator, tenant: string, args: JsonRecord): JsonRecord;
+export declare function handleCallRemoteTool(orch: RemoteOrchestrator, tenant: string, args: JsonRecord): JsonRecord;
+export declare function handleDisconnectDevice(orch: RemoteOrchestrator, tenant: string, args: JsonRecord): JsonRecord;
+export declare function handleUninstallAbility(orch: RemoteOrchestrator, tenant: string, args: JsonRecord): JsonRecord;
+export declare function handlePackageAbility(tenant: string, args: JsonRecord, signature: string): JsonRecord;
+export declare function handleDeployAbilityPackage(orch: RemoteOrchestrator, tenant: string, args: JsonRecord, signature: string): JsonRecord;
+export declare function handleDeployAbility(orch: RemoteOrchestrator, tenant: string, args: JsonRecord, signature: string): JsonRecord;
+export declare function handleExecuteCommand(orch: RemoteOrchestrator, tenant: string, args: JsonRecord, signature: string): JsonRecord;

package/src/presets/remote_control/handlers.js

@@ -0,0 +1,279 @@
+// EasyNet Axon for AgentNet
+// =========================
+//
+// File: sdk/node/src/presets/remote_control/handlers.ts
+// Description: MCP tool handlers for remote device control workflows.
+//
+// Author: Silan.Hu
+// Email: silan.hu@u.nus.edu
+// Copyright (c) 2026-2027 easynet. All rights reserved.
+import { buildDescriptor, buildPythonSubprocessTemplate, parseBool, parseDescriptor, serializeDescriptor, } from "./descriptor.js";
+import { asString } from "./config.js";
+// ---------------------------------------------------------------------------
+// Architecture: ability_lifecycle vs presets/remote_control
+//
+//   ability_lifecycle (SDK user API)   ← typed AbilityDescriptor, DeployTrace
+//           │
+//           ▼
+//   presets/remote_control (MCP layer) ← untyped JSON args from MCP dispatch
+//           │
+//           ▼
+//   dendrite_bridge (FFI)              ← native C ABI
+//
+// Handlers here receive untyped args from MCP tool dispatch and delegate to
+// the orchestrator for deployment pipelines. The ability_lifecycle module
+// provides the higher-level typed API for SDK consumers.
+//
+// Note: These handlers use the orchestrator directly (not ability_lifecycle)
+// because they need finer-grained control over cleanup and error reporting
+// in the MCP response format.
+// ---------------------------------------------------------------------------
+const INVOCATION_COMPLETED = 5;
+export function resolveDescriptor(args, fallbackSignature) {
+    return args.package ? parseDescriptor(args.package) : buildDescriptor(args, fallbackSignature);
+}
+export function handleDiscoverNodes(orch, tenant) {
+    const nodes = orch.listNodes("");
+    return {
+        ok: true,
+        tenant_id: tenant,
+        count: nodes.length,
+        nodes: nodes.map((node) => ({
+            node_id: node.node_id,
+            online: node.online,
+            display_name: node.display_name,
+        })),
+    };
+}
+export function handleListRemoteTools(orch, tenant, args) {
+    const nodeId = String(args.node_id || "").trim();
+    const pattern = String(args.name_pattern || "");
+    const tools = orch.listMcpTools(pattern, [], nodeId);
+    return {
+        ok: true,
+        tenant_id: tenant,
+        count: tools.length,
+        node_id: nodeId,
+        name_pattern: pattern,
+        tools: tools.map((tool) => ({
+            tool_name: tool.tool_name,
+            description: tool.description,
+            capability_name: tool.capability_name,
+            available_nodes: tool.available_nodes,
+            node_ids: tool.node_ids,
+        })),
+    };
+}
+export function handleCallRemoteTool(orch, tenant, args) {
+    const toolName = String(args.tool_name || "").trim();
+    const nodeId = String(args.node_id || "").trim();
+    if (!toolName || !nodeId) {
+        return {
+            ok: false,
+            tenant_id: tenant,
+            error: !toolName ? "tool_name is required" : "node_id is required",
+        };
+    }
+    const callArgs = typeof args.arguments === "object" && !Array.isArray(args.arguments) ? args.arguments : {};
+    const call = orch.callMcpTool(toolName, nodeId, callArgs);
+    const failed = asNumber(call.state) !== INVOCATION_COMPLETED || asBool(call.is_error);
+    return { ok: !failed, tenant_id: tenant, tool_name: toolName, node_id: nodeId, call };
+}
+export function handleDisconnectDevice(orch, tenant, args) {
+    const nodeId = String(args.node_id || "").trim();
+    if (!nodeId) {
+        return { ok: false, tenant_id: tenant, error: "node_id is required" };
+    }
+    const reason = String(args.reason || "").trim() || "disconnect_device: requested by agent";
+    const response = orch.disconnectDevice(nodeId, reason);
+    return {
+        ok: true,
+        tenant_id: tenant,
+        node_id: nodeId,
+        status: "disconnected",
+        response,
+    };
+}
+export function handleUninstallAbility(orch, tenant, args) {
+    const nodeId = String(args.node_id || "").trim();
+    const installId = String(args.install_id || "").trim();
+    if (!nodeId) {
+        return { ok: false, tenant_id: tenant, error: "node_id is required" };
+    }
+    if (!installId) {
+        return { ok: false, tenant_id: tenant, node_id: nodeId, error: "install_id is required" };
+    }
+    const reason = String(args.reason || "").trim() || "uninstall_ability: requested by agent";
+    const response = orch.uninstallAbility(nodeId, installId, reason);
+    return {
+        ok: true,
+        tenant_id: tenant,
+        node_id: nodeId,
+        install_id: installId,
+        status: "uninstalled",
+        response,
+    };
+}
+export function handlePackageAbility(tenant, args, signature) {
+    const descriptor = buildDescriptor(args, signature);
+    return { ok: true, tenant_id: tenant, package: serializeDescriptor(descriptor) };
+}
+export function handleDeployAbilityPackage(orch, tenant, args, signature) {
+    const nodeId = String(args.node_id || "").trim();
+    if (!nodeId) {
+        return { ok: false, tenant_id: tenant, error: "node_id is required" };
+    }
+    const descriptor = resolveDescriptor(args, signature);
+    const cleanup = parseBool(args.cleanup_on_activate_failure ?? true);
+    const deployed = orch.deployAbilityPackage(descriptor, nodeId, cleanup);
+    return {
+        ok: true,
+        tenant_id: tenant,
+        node_id: nodeId,
+        package: serializeDescriptor(descriptor),
+        ...deployed,
+    };
+}
+// ---------------------------------------------------------------------------
+// AI-AGENT PRESET HANDLERS
+// handleDeployAbility and handleExecuteCommand are convenience presets designed
+// for AI agent workflows. They wrap the generic package_ability /
+// deploy_ability_package pipeline into single-call operations.
+// ---------------------------------------------------------------------------
+export function handleDeployAbility(orch, tenant, args, signature) {
+    const nodeId = String(args.node_id || "").trim();
+    if (!nodeId) {
+        return { ok: false, tenant_id: tenant, error: "node_id is required" };
+    }
+    const commandTemplate = String(args.command_template || "").trim();
+    if (!commandTemplate) {
+        return { ok: false, tenant_id: tenant, node_id: nodeId, error: "command_template is required" };
+    }
+    const toolName = String(args.tool_name || `tool_${Date.now()}`).trim();
+    const descriptor = buildDescriptor({
+        ...args,
+        ability_name: toolName,
+        tool_name: toolName,
+        description: String(args.description || `Tool ${toolName}`),
+        command_template: commandTemplate,
+    }, signature);
+    const deploy = orch.deployAbilityPackage(descriptor, nodeId, true);
+    return {
+        ok: true,
+        tenant_id: tenant,
+        node_id: nodeId,
+        tool_name: descriptor.toolName,
+        package_id: descriptor.packageId,
+        install_id: deploy.install_id,
+        description: String(args.description || `Tool ${toolName}`),
+        deploy,
+    };
+}
+export function handleExecuteCommand(orch, tenant, args, signature) {
+    const nodeId = String(args.node_id || "").trim();
+    const command = String(args.command || "").trim();
+    if (!nodeId)
+        return { ok: false, tenant_id: tenant, error: "node_id is required" };
+    if (!command)
+        return { ok: false, tenant_id: tenant, node_id: nodeId, error: "command is required" };
+    const shouldCleanup = args.cleanup == null ? true : parseBool(args.cleanup);
+    const toolName = `cmd_${Date.now()}_${Math.floor(Math.random() * 1e4).toString(16)}`;
+    const descriptor = buildDescriptor({
+        ability_name: toolName,
+        tool_name: toolName,
+        description: `execute command: ${command}`,
+        command_template: buildPythonSubprocessTemplate(command),
+        tags: ["mcp", "ability", "execute-command"],
+        signature_base64: signature,
+    }, signature);
+    try {
+        const deploy = orch.deployAbilityPackage(descriptor, nodeId, shouldCleanup);
+        const actualTool = String(deploy.tool_name || descriptor.toolName);
+        const installId = asString(deploy.install_id);
+        const call = orch.callMcpTool(actualTool, nodeId, {});
+        const failed = asNumber(call.state) !== INVOCATION_COMPLETED || asBool(call.is_error);
+        const error = failed ? asString(call.error) : "";
+        return {
+            ok: !failed,
+            tenant_id: tenant,
+            node_id: nodeId,
+            tool_name: actualTool,
+            command,
+            deploy: serializeDescriptor(descriptor),
+            call,
+            cleanup: shouldCleanup ? orch.cleanupInstalls([{ mode: "execute_command", nodeId, installId }]) : { attempted: false, ok: false, reason: "cleanup disabled" },
+            ...(error ? { error } : {}),
+        };
+    }
+    catch (error) {
+        const failure = parseDeployFailure(error);
+        const cleanup = parseCleanupSummary(failure, orch, nodeId, shouldCleanup);
+        return {
+            ok: false,
+            tenant_id: tenant,
+            node_id: nodeId,
+            tool_name: toolName,
+            command,
+            deploy: serializeDescriptor(descriptor),
+            install_id: asString(failure.install_id),
+            cleanup,
+            error: extractErrorMessage(error, failure),
+        };
+    }
+}
+function asBool(raw) {
+    if (typeof raw === "boolean")
+        return raw;
+    if (typeof raw === "number")
+        return raw !== 0;
+    const normalized = String(raw ?? "").trim().toLowerCase();
+    return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on";
+}
+function asNumber(raw) {
+    if (typeof raw === "number")
+        return raw;
+    const value = Number.parseInt(String(raw ?? "0"), 10);
+    return Number.isFinite(value) ? value : 0;
+}
+function parseDeployFailure(error) {
+    const message = error instanceof Error ? error.message : String(error ?? "");
+    try {
+        const parsed = JSON.parse(message);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore; keep raw.
+    }
+    return { message: "deploy_ability_package failed", error: message };
+}
+function extractErrorMessage(error, failure) {
+    if (typeof failure.message === "string" && failure.message.trim()) {
+        return failure.message;
+    }
+    if (typeof failure.error === "string" && failure.error.trim()) {
+        return failure.error;
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+function parseCleanupSummary(failure, orch, nodeId, shouldCleanup) {
+    const cleanupFromFailure = failure.cleanup;
+    if (cleanupFromFailure && typeof cleanupFromFailure === "object" && !Array.isArray(cleanupFromFailure)) {
+        return cleanupFromFailure;
+    }
+    if (!shouldCleanup) {
+        return { attempted: false, ok: false, reason: "cleanup disabled" };
+    }
+    const installId = asString(typeof failure.install_id === "string" ? failure.install_id : String(failure.install_id || ""));
+    if (!installId) {
+        return { attempted: false, ok: false, reason: "install_id empty" };
+    }
+    return orch.cleanupInstalls([
+        {
+            mode: "publish_install_activate",
+            nodeId,
+            installId,
+        },
+    ]);
+}

package/src/presets/remote_control/kit.d.ts

@@ -0,0 +1,22 @@
+import type { McpToolProvider, McpToolResult } from "../../mcp/server.js";
+import { type RemoteControlRuntimeConfig } from "./config.js";
+import { type JsonRecord } from "./descriptor.js";
+import { type OrchestratorFactory } from "./orchestrator.js";
+export type { RemoteControlRuntimeConfig } from "./config.js";
+export interface RemoteOrchestratorFactory extends OrchestratorFactory {
+}
+export declare class RemoteControlCaseKit implements McpToolProvider {
+    private readonly config;
+    private readonly orchestratorFactory;
+    constructor(config: RemoteControlRuntimeConfig, orchestratorFactory?: OrchestratorFactory);
+    static loadConfigFromEnv(): RemoteControlRuntimeConfig;
+    static loadRemoteControlConfigFromEnv(): RemoteControlRuntimeConfig;
+    static ensureNativeLibEnv(): void;
+    static ensureRemoteControlNativeLibEnv(): void;
+    toolSpecs(): Array<JsonRecord>;
+    handleToolCall(name: string, args: JsonRecord): McpToolResult;
+    private dispatch;
+    private withOrchestrator;
+    private toolResult;
+    private toolResultWithPayload;
+}