agenticros 0.0.1 → 0.1.1

package/runtime/packages/agenticros/src/commands/transport.ts

@@ -0,0 +1,195 @@
+import type { OpenClawPluginApi } from "../plugin-api.js";
+import type { AgenticROSConfig } from "@agenticros/core";
+import type { TransportConfig } from "@agenticros/core";
+import { getTransport, getTransportMode, switchTransport } from "../service.js";
+import { clearDiscoveryCache } from "../context/robot-context.js";
+
+const VALID_MODES = ["rosbridge", "local", "webrtc", "zenoh"] as const;
+type Mode = (typeof VALID_MODES)[number];
+
+function isValidMode(value: string): value is Mode {
+  return (VALID_MODES as readonly string[]).includes(value);
+}
+
+/**
+ * Register the /transport command for runtime transport switching.
+ */
+export function registerTransportCommand(api: OpenClawPluginApi, config: AgenticROSConfig): void {
+  api.registerCommand({
+    name: "transport",
+    description: "Show or switch the ROS2 transport mode (rosbridge, webrtc, local, zenoh)",
+
+    async handler(ctx) {
+      const args = (ctx.args ?? "").trim();
+
+      // No args → show current status
+      if (!args) {
+        return showStatus();
+      }
+
+      // Parse mode from first arg
+      const parts = args.split(/\s+/);
+      const modeArg = parts[0];
+
+      if (!isValidMode(modeArg)) {
+        return {
+          text: `Unknown transport mode: "${modeArg}". Valid modes: ${VALID_MODES.join(", ")}`,
+        };
+      }
+
+      // Build TransportConfig from base config + overrides
+      let transportConfig: TransportConfig;
+      try {
+        transportConfig = buildTransportConfig(modeArg, parts.slice(1), config);
+      } catch (err) {
+        return { text: `Invalid arguments: ${String(err)}` };
+      }
+
+      // Perform the switch
+      try {
+        await switchTransport(transportConfig, api.logger);
+        clearDiscoveryCache();
+        return { text: formatSwitchSuccess(transportConfig) };
+      } catch (err) {
+        return {
+          text: `Failed to switch transport: ${String(err)}\nYou can retry with /transport ${modeArg}`,
+        };
+      }
+    },
+  });
+}
+
+function showStatus(): { text: string } {
+  const mode = getTransportMode();
+
+  if (!mode) {
+    return { text: "Transport: not active" };
+  }
+
+  try {
+    const transport = getTransport();
+    const status = transport.getStatus();
+    return { text: `Transport: ${mode} (${status})` };
+  } catch {
+    return { text: `Transport: ${mode} (unknown status)` };
+  }
+}
+
+/**
+ * Build a TransportConfig from base config + positional/key=value overrides.
+ */
+function buildTransportConfig(
+  mode: Mode,
+  overrides: string[],
+  config: AgenticROSConfig,
+): TransportConfig {
+  switch (mode) {
+    case "rosbridge": {
+      const base = { ...config.rosbridge };
+
+      for (const arg of overrides) {
+        if (arg.startsWith("ws://") || arg.startsWith("wss://")) {
+          // Positional URL override
+          base.url = arg;
+        } else if (arg.includes("=")) {
+          const [key, ...rest] = arg.split("=");
+          const value = rest.join("=");
+          applyOverride(base, key, value);
+        } else {
+          throw new Error(`Unexpected argument: "${arg}"`);
+        }
+      }
+
+      return { mode: "rosbridge", rosbridge: base };
+    }
+
+    case "webrtc": {
+      const base = { ...config.webrtc };
+
+      for (const arg of overrides) {
+        if (!arg.includes("=")) {
+          throw new Error(`Unexpected argument: "${arg}". Use key=value format.`);
+        }
+        const [key, ...rest] = arg.split("=");
+        const value = rest.join("=");
+        applyOverride(base, key, value);
+      }
+
+      return { mode: "webrtc", webrtc: base };
+    }
+
+    case "local": {
+      const base = { ...config.local };
+
+      for (const arg of overrides) {
+        if (!arg.includes("=")) {
+          throw new Error(`Unexpected argument: "${arg}". Use key=value format.`);
+        }
+        const [key, ...rest] = arg.split("=");
+        const value = rest.join("=");
+        applyOverride(base, key, value);
+      }
+
+      return { mode: "local", local: base };
+    }
+
+    case "zenoh": {
+      const base = { ...config.zenoh };
+
+      for (const arg of overrides) {
+        if (arg.includes("=")) {
+          const [key, ...rest] = arg.split("=");
+          const value = rest.join("=");
+          applyOverride(base as Record<string, unknown>, key, value);
+        } else if (arg.startsWith("ws://") || arg.startsWith("wss://") || /^[a-z]+\/\S+/.test(arg)) {
+          base.routerEndpoint = arg;
+        } else {
+          throw new Error(`Unexpected argument: "${arg}". Use key=value or router endpoint.`);
+        }
+      }
+
+      return { mode: "zenoh", zenoh: base };
+    }
+  }
+}
+
+/** Apply a key=value override to a config object. */
+function applyOverride(obj: Record<string, unknown>, key: string, value: string): void {
+  if (!(key in obj)) {
+    throw new Error(`Unknown config key: "${key}"`);
+  }
+
+  const existing = obj[key];
+
+  // Coerce value to match existing type
+  if (typeof existing === "number") {
+    const num = Number(value);
+    if (Number.isNaN(num)) {
+      throw new Error(`"${key}" expects a number, got "${value}"`);
+    }
+    obj[key] = num;
+  } else if (typeof existing === "boolean") {
+    obj[key] = value === "true";
+  } else {
+    obj[key] = value;
+  }
+}
+
+function formatSwitchSuccess(config: TransportConfig): string {
+  switch (config.mode) {
+    case "rosbridge":
+      return `Switched to rosbridge transport (${config.rosbridge.url})`;
+    case "webrtc": {
+      const robotId = config.webrtc.robotId;
+      return `Switched to webrtc transport (robotId: ${robotId})`;
+    }
+    case "local":
+      return `Switched to local transport (domainId: ${config.local?.domainId ?? 0})`;
+    case "zenoh":
+      return `Switched to zenoh transport (${config.zenoh.routerEndpoint})`;
+    default: {
+      const _: never = config;
+      return `Switched to ${(_ as TransportConfig).mode} transport`;
+    }
+  }
+}

package/runtime/packages/agenticros/src/config-file.ts

@@ -0,0 +1,136 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import type { AgenticROSConfig } from "@agenticros/core";
+import { parseConfig } from "@agenticros/core";
+
+/**
+ * Resolve the OpenClaw config file path.
+ * Same convention as scripts/configure_agenticros.sh: OPENCLAW_CONFIG or ~/.openclaw/openclaw.json
+ */
+export function getOpenClawConfigPath(): string {
+  const env = process.env.OPENCLAW_CONFIG;
+  if (env && env.length > 0) {
+    return path.resolve(env);
+  }
+  return path.join(os.homedir(), ".openclaw", "openclaw.json");
+}
+
+export class ConfigFileError extends Error {
+  constructor(
+    message: string,
+    public readonly code?: "ENOENT" | "EACCES" | "INVALID_JSON",
+  ) {
+    super(message);
+    this.name = "ConfigFileError";
+  }
+}
+
+/**
+ * Read and parse the full OpenClaw config file.
+ * @throws ConfigFileError if file is missing or invalid JSON
+ */
+export function readOpenClawConfig(): Record<string, unknown> {
+  const configPath = getOpenClawConfigPath();
+  let raw: string;
+  try {
+    raw = fs.readFileSync(configPath, "utf8");
+  } catch (err) {
+    const nodeErr = err as NodeJS.ErrnoException;
+    if (nodeErr.code === "ENOENT") {
+      throw new ConfigFileError(
+        `Config file not found: ${configPath}. Create it by running OpenClaw configure once, or set OPENCLAW_CONFIG.`,
+        "ENOENT",
+      );
+    }
+    if (nodeErr.code === "EACCES") {
+      throw new ConfigFileError(
+        `Cannot read config file: ${configPath}. Check permissions.`,
+        "EACCES",
+      );
+    }
+    throw new ConfigFileError(
+      nodeErr.message ?? "Failed to read config file",
+      "EACCES",
+    );
+  }
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (parsed !== null && typeof parsed === "object") {
+      return parsed as Record<string, unknown>;
+    }
+  } catch {
+    throw new ConfigFileError("Config file is not valid JSON.", "INVALID_JSON");
+  }
+  throw new ConfigFileError("Config file is not valid JSON.", "INVALID_JSON");
+}
+
+/**
+ * Ensure plugins.entries.agenticros exists in the config object (mutates in place).
+ */
+function ensureAgenticROSEntry(full: Record<string, unknown>): void {
+  if (!full.plugins || typeof full.plugins !== "object") {
+    full.plugins = {};
+  }
+  const plugins = full.plugins as Record<string, unknown>;
+  if (!plugins.entries || typeof plugins.entries !== "object") {
+    plugins.entries = {};
+  }
+  const entries = plugins.entries as Record<string, unknown>;
+  if (!entries.agenticros || typeof entries.agenticros !== "object") {
+    entries.agenticros = {};
+  }
+}
+
+/**
+ * Write AgenticROS plugin config into the OpenClaw config file.
+ * Reads the file, sets plugins.entries.agenticros.config, writes back.
+ * @throws ConfigFileError on read/write errors
+ */
+export function writeAgenticROSConfig(pluginConfig: Record<string, unknown>): void {
+  const configPath = getOpenClawConfigPath();
+  const full = readOpenClawConfig();
+  ensureAgenticROSEntry(full);
+  const plugins = full.plugins as Record<string, unknown>;
+  const entries = plugins.entries as Record<string, unknown>;
+  const agenticrosEntry = entries.agenticros as Record<string, unknown>;
+  agenticrosEntry.config = pluginConfig;
+
+  try {
+    fs.writeFileSync(configPath, JSON.stringify(full, null, 2), "utf8");
+  } catch (err) {
+    const nodeErr = err as NodeJS.ErrnoException;
+    if (nodeErr.code === "EACCES" || nodeErr.code === "EPERM") {
+      throw new ConfigFileError(
+        `Cannot write config file: ${configPath}. Check permissions.`,
+        "EACCES",
+      );
+    }
+    throw new ConfigFileError(
+      nodeErr.message ?? "Failed to write config file",
+      "EACCES",
+    );
+  }
+}
+
+/**
+ * Read the current AgenticROS plugin config from the OpenClaw config file.
+ * Use this when handling requests so teleop/tools use the latest saved config (e.g. robot.namespace)
+ * without requiring a gateway restart.
+ * Preserves webrtc.robotKey from the file if set.
+ */
+export function readAgenticROSConfigFromFile(): AgenticROSConfig {
+  const full = readOpenClawConfig();
+  const plugins = full.plugins as Record<string, unknown> | undefined;
+  const entries = plugins?.entries as Record<string, unknown> | undefined;
+  const agenticrosEntry = entries?.agenticros as Record<string, unknown> | undefined;
+  const raw = agenticrosEntry?.config;
+  const obj = raw && typeof raw === "object" && raw !== null ? (raw as Record<string, unknown>) : {};
+  const parsed = parseConfig(obj);
+  const existing = agenticrosEntry?.config as Record<string, unknown> | undefined;
+  const existingKey = (existing?.webrtc as Record<string, unknown> | undefined)?.robotKey;
+  if (typeof existingKey === "string" && existingKey.length > 0) {
+    parsed.webrtc.robotKey = existingKey;
+  }
+  return parsed;
+}