@seeed-studio/meshtastic 0.1.1 → 0.2.0

package/src/onboarding.ts

@@ -1,3 +1,4 @@
+import { readdir } from "node:fs/promises";
 import {
   addWildcardAllowFrom,
   DEFAULT_ACCOUNT_ID,
@@ -24,6 +25,57 @@ import type {
 
 const channel = "meshtastic" as const;
 
+async function detectMeshtasticSerialPortCandidates(): Promise<string[]> {
+  const candidates = new Set<string>();
+
+  try {
+    const devEntries = await readdir("/dev");
+    for (const entry of devEntries) {
+      if (
+        entry.startsWith("cu.usb")
+        || entry.startsWith("tty.usb")
+        || entry.startsWith("ttyUSB")
+        || entry.startsWith("ttyACM")
+      ) {
+        candidates.add(`/dev/${entry}`);
+      }
+    }
+  } catch {}
+
+  try {
+    const byIdEntries = await readdir("/dev/serial/by-id");
+    for (const entry of byIdEntries) {
+      candidates.add(`/dev/serial/by-id/${entry}`);
+    }
+  } catch {}
+
+  return [...candidates].sort((a, b) => a.localeCompare(b));
+}
+
+const REGION_OPTIONS: { value: string; label: string }[] = [
+  { value: "US", label: "US (902-928 MHz)" },
+  { value: "EU_433", label: "EU_433 (433 MHz)" },
+  { value: "EU_868", label: "EU_868 (869 MHz)" },
+  { value: "CN", label: "CN (470-510 MHz)" },
+  { value: "JP", label: "JP (920 MHz)" },
+  { value: "ANZ", label: "ANZ (915-928 MHz)" },
+  { value: "KR", label: "KR (920-923 MHz)" },
+  { value: "TW", label: "TW (920-925 MHz)" },
+  { value: "RU", label: "RU (868 MHz)" },
+  { value: "IN", label: "IN (865-867 MHz)" },
+  { value: "TH", label: "TH (920-925 MHz)" },
+  { value: "LORA_24", label: "LORA_24 (2.4 GHz)" },
+];
+
+function regionToMqttTopic(region: string): string {
+  return `msh/${region}/2/json/#`;
+}
+
+function parseRegionFromTopic(topic: string): string | undefined {
+  const match = topic.match(/^msh\/([^/]+)\//);
+  return match?.[1];
+}
+
 function parseListInput(raw: string): string[] {
   return raw
     .split(/[\n,;]+/g)
@@ -227,14 +279,39 @@ export const meshtasticOnboardingAdapter: ChannelOnboardingAdapter = {
     const transport = String(transportChoice) as MeshtasticTransport;
 
     if (transport === "serial") {
-      const serialPort = String(
-        await prompter.text({
-          message: "Serial port path",
-          placeholder: "/dev/ttyUSB0 or /dev/tty.usbmodem*",
-          initialValue: resolved.serialPort || undefined,
-          validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
-        }),
-      ).trim();
+      const serialCandidates = await detectMeshtasticSerialPortCandidates();
+      let serialPort = resolved.serialPort || "";
+      let needsManualSerialInput = true;
+
+      if (serialCandidates.length > 0) {
+        const initialDetected = serialCandidates.includes(serialPort)
+          ? serialPort
+          : serialCandidates[0];
+        const detectedChoice = await prompter.select({
+          message: "Detected serial port",
+          options: [
+            ...serialCandidates.map((value) => ({ value, label: value })),
+            { value: "__manual__", label: "Manual input" },
+          ],
+          initialValue: initialDetected,
+        });
+        const selected = String(detectedChoice);
+        if (selected !== "__manual__") {
+          serialPort = selected;
+          needsManualSerialInput = false;
+        }
+      }
+
+      if (needsManualSerialInput) {
+        serialPort = String(
+          await prompter.text({
+            message: "Serial port path",
+            placeholder: "/dev/ttyUSB0 or /dev/tty.usbmodem*",
+            initialValue: serialPort || undefined,
+            validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
+          }),
+        ).trim();
+      }
 
       next = updateMeshtasticAccountConfig(next, accountId, {
         enabled: true,
@@ -295,10 +372,20 @@ export const meshtasticOnboardingAdapter: ChannelOnboardingAdapter = {
         }),
       ).trim();
 
+      // Region selection — generates the default MQTT topic.
+      const existingTopic = resolved.config.mqtt?.topic || "msh/US/2/json/#";
+      const currentMqttRegion = parseRegionFromTopic(existingTopic) ?? "US";
+      const mqttRegionChoice = await prompter.select({
+        message: "LoRa region (determines which mesh traffic to receive)",
+        options: REGION_OPTIONS,
+        initialValue: currentMqttRegion,
+      });
+      const mqttRegion = String(mqttRegionChoice);
+
       const topic = String(
         await prompter.text({
           message: "MQTT subscribe topic",
-          initialValue: resolved.config.mqtt?.topic || "msh/US/2/json/#",
+          initialValue: regionToMqttTopic(mqttRegion),
           validate: (value) => (String(value ?? "").trim() ? undefined : "Required"),
         }),
       ).trim();
@@ -328,18 +415,7 @@ export const meshtasticOnboardingAdapter: ChannelOnboardingAdapter = {
         message: "LoRa region",
         options: [
           { value: "UNSET", label: "UNSET (keep device default)" },
-          { value: "US", label: "US (902-928 MHz)" },
-          { value: "EU_433", label: "EU_433 (433 MHz)" },
-          { value: "EU_868", label: "EU_868 (869 MHz)" },
-          { value: "CN", label: "CN (470-510 MHz)" },
-          { value: "JP", label: "JP (920 MHz)" },
-          { value: "ANZ", label: "ANZ (915-928 MHz)" },
-          { value: "KR", label: "KR (920-923 MHz)" },
-          { value: "TW", label: "TW (920-925 MHz)" },
-          { value: "RU", label: "RU (868 MHz)" },
-          { value: "IN", label: "IN (865-867 MHz)" },
-          { value: "TH", label: "TH (920-925 MHz)" },
-          { value: "LORA_24", label: "LORA_24 (2.4 GHz)" },
+          ...REGION_OPTIONS,
         ],
         initialValue: resolved.config.region ?? "UNSET",
       });
@@ -352,11 +428,19 @@ export const meshtasticOnboardingAdapter: ChannelOnboardingAdapter = {
     // Device display name — also used as a mention pattern so users can
     // @NodeName the bot in group channels.
     const currentNodeName = resolveMeshtasticAccount({ cfg: next, accountId }).config.nodeName;
+    const isMqtt = transport === "mqtt";
     const nodeNameInput = String(
       await prompter.text({
-        message: "Device display name (also used as @mention trigger)",
-        placeholder: "e.g. OpenClaw",
+        message: isMqtt
+          ? "Device display name (required for MQTT — used as @mention trigger)"
+          : "Device display name (leave empty to auto-detect from device)",
+        placeholder: isMqtt
+          ? "e.g. OpenClaw"
+          : "e.g. OpenClaw (empty = use device's current name)",
         initialValue: currentNodeName || undefined,
+        validate: isMqtt
+          ? (value) => (String(value ?? "").trim() ? undefined : "Required for MQTT (no device to auto-detect from)")
+          : undefined,
       }),
     ).trim();
     if (nodeNameInput) {

package/src/policy.ts

@@ -137,11 +137,15 @@ export function resolveMeshtasticGroupSenderAllowed(params: {
   const inner = normalizeMeshtasticAllowlist(params.innerAllowFrom);
   const outer = normalizeMeshtasticAllowlist(params.outerAllowFrom);
 
+  // Fallback strategy: check channel-specific allowlist first, then fall
+  // back to the global allowlist.  This ensures global admin nodes are
+  // never locked out of channels that define their own lists.
   if (inner.length > 0) {
-    return resolveMeshtasticAllowlistMatch({
+    const innerResult = resolveMeshtasticAllowlistMatch({
       allowFrom: inner,
       message: params.message,
-    }).allowed;
+    });
+    if (innerResult.allowed) return true;
   }
   if (outer.length > 0) {
     return resolveMeshtasticAllowlistMatch({

package/src/send.ts

@@ -1,4 +1,7 @@
 import { randomUUID } from "node:crypto";
+
+import { stripMarkdown } from "openclaw/plugin-sdk";
+
 import { resolveMeshtasticAccount } from "./accounts.js";
 import { hexToNodeNum, normalizeMeshtasticMessagingTarget } from "./normalize.js";
 import { getMeshtasticRuntime } from "./runtime.js";
@@ -50,13 +53,15 @@ export async function sendMessageMeshtastic(
   if (!account.configured) {
     throw new Error(
       `Meshtastic is not configured for account "${account.accountId}". ` +
-        `Set channels.meshtastic.transport and connection details.`,
+        `Run 'openclaw setup' or set channels.meshtastic.transport and connection details in config.`,
     );
   }
 
   const target = normalizeMeshtasticMessagingTarget(to);
   if (!target) {
-    throw new Error(`Invalid Meshtastic target: ${to}`);
+    throw new Error(
+      `Invalid Meshtastic target: "${to}". Use a node ID like "!aabbccdd" or a channel name like "channel:LongFast".`,
+    );
   }
 
   const tableMode = runtime.channel.text.resolveMarkdownTableMode({
@@ -65,7 +70,8 @@ export async function sendMessageMeshtastic(
     accountId: account.accountId,
   });
   const prepared = runtime.channel.text.convertMarkdownTables(text.trim(), tableMode);
-  if (!prepared.trim()) {
+  const stripped = stripMarkdown(prepared);
+  if (!stripped.trim()) {
     throw new Error("Message must be non-empty for Meshtastic sends");
   }
 
@@ -73,17 +79,17 @@ export async function sendMessageMeshtastic(
 
   if (transport === "mqtt") {
     if (activeMqttSend) {
-      await activeMqttSend(prepared, target, opts.channelName);
+      await activeMqttSend(stripped, target, opts.channelName);
     } else {
-      throw new Error("No active MQTT connection. Start the gateway first.");
+      throw new Error("No active MQTT connection. Run 'openclaw gateway start' to connect.");
     }
   } else {
     // Serial or HTTP: use active transport if available.
     if (activeSerialSend) {
       const destination = target.startsWith("!") ? hexToNodeNum(target) : undefined;
-      await activeSerialSend(prepared, destination, opts.channelIndex);
+      await activeSerialSend(stripped, destination, opts.channelIndex);
     } else {
-      throw new Error(`No active ${transport} connection. Start the gateway first.`);
+      throw new Error(`No active ${transport} connection. Run 'openclaw gateway start' to connect.`);
     }
   }
 

package/src/types.ts

@@ -28,6 +28,8 @@ export type MeshtasticMqttConfig = {
   topic?: string;
   publishTopic?: string;
   tls?: boolean;
+  /** Own node ID in !hex format — required for DM detection over MQTT. */
+  myNodeId?: string;
 };
 
 export type MeshtasticTransport = "serial" | "http" | "mqtt";