4bnode 4.2.0 → 4.2.1

package/add-bonjour.js

@@ -2,7 +2,8 @@
 
 import fs from "fs";
 import path from "path";
-import { input } from "@inquirer/prompts";
+import { input, select } from "@inquirer/prompts";
+import { pathToFileURL } from "url";
 import { getProjectRoot } from "./lib/project.js";
 import { updateEnvFile } from "./lib/env.js";
 import { readIndex, writeIndex } from "./lib/indexFile.js";
@@ -45,6 +46,30 @@ async function main() {
   fs.writeFileSync(discoveryPath, buildDiscoveryModule(), "utf8");
   showFileAction(existed ? "updated" : "created", "src/discovery.js");
 
+  // 1b. Which network to advertise on. Load the module just written so the CLI
+  //     detects networks exactly like the running app and the dashboard do.
+  let iface = "";
+  try {
+    const { listNetworkInterfaces } = await import(pathToFileURL(discoveryPath).href);
+    const nets = listNetworkInterfaces();
+    if (nets.length > 1) {
+      iface = await select({
+        message: "Several networks are connected. Which one should Bonjour advertise on?",
+        choices: [
+          ...nets.map((n) => ({
+            name: `${n.label}  ${n.address}${n.selfAssigned ? "  (no network: self-assigned IP)" : ""}`,
+            value: n.name,
+          })),
+          { name: "All networks", value: "" },
+        ],
+      });
+    } else if (nets.length === 1) {
+      showInfo(`Network: ${nets[0].label} ${nets[0].address}`);
+    }
+  } catch {
+    // Detection is best-effort; blank means "all networks".
+  }
+
   // 2. Wire it into index.js (idempotent — a no-op if already wired).
   try {
     const before = readIndex();
@@ -66,6 +91,7 @@ async function main() {
 
   // 3. Configuration in .env.
   updateEnvFile(envPath, "BONJOUR_ENABLED", "on");
+  updateEnvFile(envPath, "BONJOUR_INTERFACE", iface);
   if (name) updateEnvFile(envPath, "BONJOUR_NAME", name);
   if (type && type !== "http") updateEnvFile(envPath, "BONJOUR_TYPE", type);
   showFileAction("updated", ".env");
@@ -76,8 +102,10 @@ async function main() {
   showTaskDone("Bonjour / mDNS discovery enabled", [
     name ? `Service name: ${name}` : "Service name: app name + hostname",
     `Service type: _${type}._tcp`,
+    `Network: ${iface || "all networks"} (change with BONJOUR_INTERFACE or in the dashboard)`,
     "Advertises once the server is listening; sends goodbye packets on clean shutdown",
     "Browse peers on the network from the /_dev dashboard → Discovery",
+    "Bonjour is off by default in new projects; this command turned it on (BONJOUR_ENABLED=on)",
     "Disable anytime with BONJOUR_ENABLED=off in .env",
   ]);
 }

package/add-email.js

@@ -3,6 +3,7 @@
 import fs from "fs";
 import path from "path";
 import os from "os";
+import crypto from "crypto";
 import { createRequire } from "module";
 import { pathToFileURL } from "url";
 import { input, select, confirm, password } from "@inquirer/prompts";
@@ -15,6 +16,8 @@ import {
   isOfficialMailDomain,
   OFFICIAL_MAIL_DOMAIN_PASSWORD,
   OFFICIAL_MAIL_NOTIFY,
+  SANCHARAK_API_URL,
+  sancharakKeyProblem,
 } from "./lib/codegen.js";
 
 // The 4brains.in domain can't be configured directly — require the shared
@@ -48,11 +51,18 @@ async function sendOfficialNotify(root, ctx) {
     "Time: " + new Date().toISOString(),
   ].join("\n");
 
-  if (ctx.kind === "resend") {
-    const { Resend } = await import(pathToFileURL(require.resolve("resend")).href);
-    const resend = new Resend(ctx.apiKey);
-    const { error } = await resend.emails.send({ from: ctx.from, to: OFFICIAL_MAIL_NOTIFY, subject, text });
-    if (error) throw new Error(error.message || "Resend error");
+  if (ctx.kind === "sancharak") {
+    const res = await fetch(SANCHARAK_API_URL, {
+      method: "POST",
+      headers: {
+        Authorization: "Bearer " + ctx.apiKey,
+        "Content-Type": "application/json",
+        "Idempotency-Key": crypto.randomUUID(),
+      },
+      body: JSON.stringify({ from: ctx.from, to: [OFFICIAL_MAIL_NOTIFY], subject, text, stream: "tx" }),
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!res.ok) throw new Error("Sancharak " + res.status + ": " + (await res.text()).slice(0, 200));
     return;
   }
   const nodemailer = (await import(pathToFileURL(require.resolve("nodemailer")).href)).default;
@@ -86,17 +96,23 @@ async function main() {
   let dep;
   let notifyCtx = null; // set when an authorized 4brains.in sender is configured
 
-  if (preset.type === "resend") {
-    // IntraApp(Postmaster) → Resend API. Only an API key + from address.
-    const apiKey = (await password({ message: "Resend API key (re_...):", mask: "*" })).trim();
-    const from = (await input({ message: "From address:", default: "" })).trim();
+  if (preset.type === "sancharak") {
+    // Sancharak HTTP API: an API key + From (+ optional Reply-to). No package needed.
+    const apiKey = (await password({
+      message: "Sancharak API key (snk_...):",
+      mask: "*",
+      validate: (v) => (!v.trim() ? true : sancharakKeyProblem(v) || true),
+    })).trim();
+    const from = (await input({ message: "From address (e.g. Your App <hello@yourdomain.com>):", default: "" })).trim();
+    const replyTo = (await input({ message: "Reply-to address (optional):", default: "" })).trim();
     await ensureOfficialAllowed(from);
     if (isOfficialMailDomain(from)) updateEnvFile(envPath, "OFFICIAL_MAIL_AUTHORIZED", "1");
-    if (apiKey) updateEnvFile(envPath, "RESEND_API_KEY", apiKey);
+    if (apiKey) updateEnvFile(envPath, "SANCHARAK_API_KEY", apiKey);
     if (from) updateEnvFile(envPath, "MAIL_FROM", from);
-    dep = "resend";
+    if (replyTo) updateEnvFile(envPath, "MAIL_REPLY_TO", replyTo);
+    dep = null;
     summary.push(from ? `From: ${from}` : "From: (set MAIL_FROM in .env)");
-    if (isOfficialMailDomain(from) && apiKey) notifyCtx = { kind: "resend", from, apiKey };
+    if (isOfficialMailDomain(from) && apiKey) notifyCtx = { kind: "sancharak", from, apiKey };
   } else {
     // Custom SMTP → nodemailer. TLS selects the port (465 vs 587).
     const host = (await input({ message: "SMTP host:", default: preset.host || "" })).trim();
@@ -123,15 +139,17 @@ async function main() {
   showFileAction("updated", ".env");
 
   fs.mkdirSync(dir, { recursive: true });
-  // Rewrite the mailer only if missing or on the old single-backend version.
-  if (!fs.existsSync(mailerPath) || !fs.readFileSync(mailerPath, "utf8").includes("MAIL_PROVIDER")) {
+  // Rewrite the mailer if missing, on the old single-backend version, or on the
+  // old Postmaster (Resend) version that Sancharak replaces.
+  const existingMailer = fs.existsSync(mailerPath) ? fs.readFileSync(mailerPath, "utf8") : "";
+  if (!existingMailer || !existingMailer.includes("MAIL_PROVIDER") || existingMailer.includes("import('resend')")) {
     fs.writeFileSync(mailerPath, buildMailerService(), "utf8");
     showFileAction(fs.existsSync(mailerPath) ? "updated" : "created", "src/services/mailer.js");
   } else {
     showInfo("src/services/mailer.js already up to date — keeping it.");
   }
 
-  await installDeps(dep);
+  if (dep) await installDeps(dep);
 
   if (notifyCtx) {
     try {

package/add-serialport.js

@@ -1,71 +1,163 @@
 #!/usr/bin/env node
 
+import fs from "fs";
 import path from "path";
-import { input } from "@inquirer/prompts";
+import { pathToFileURL } from "url";
+import { input, select, confirm } from "@inquirer/prompts";
 import { getProjectRoot } from "./lib/project.js";
-import { updateEnvFile } from "./lib/env.js";
-import { addImport, insertBeforeListen } from "./lib/indexFile.js";
+import { readIndex, writeIndex } from "./lib/indexFile.js";
 import {
   showHeader,
   showTaskDone,
   showError,
+  showInfo,
   showFileAction,
   installDeps,
 } from "./lib/ui.js";
+import {
+  buildSerialDeviceModule,
+  buildSerialDevicesModule,
+  buildSerialRouter,
+  normalizeSerialDevice,
+  wireSerialIntoIndex,
+  SERIAL_DEPS,
+  SERIAL_BAUD_RATES,
+} from "./lib/codegen.js";
 
 async function main() {
-  showHeader("add-serialport", "Add serial port communication");
+  showHeader("add-serialport", "Talk to Arduino / ESP32 boards over USB serial");
 
-  const serialPortPath = await input({
-    message: "Serial port path:",
-    default: process.platform === "win32" ? "COM3" : "/dev/tty-usbserial1",
-  });
+  showInfo(
+    "Devices are found by USB serial number, USB vendor id, or a firmware handshake " +
+      "(ID?), never a fixed COM port. They reconnect by themselves after a reset or unplug.",
+  );
 
-  const baudRate = await input({
-    message: "Baud rate:",
-    default: "9600",
-    validate: (v) => (!isNaN(parseInt(v, 10)) ? true : "Enter a valid number."),
-  });
+  const root = getProjectRoot();
+  const serialDir = path.join(root, "src", "serial");
+  const configFile = path.join(serialDir, "devices.json");
 
-  console.log();
+  // 1. Dependencies first, so the port scan below can run.
+  await installDeps(SERIAL_DEPS);
 
-  addImport("import { SerialPort } from 'serialport';");
-  addImport("import { ReadlineParser } from '@serialport/parser-readline';");
-  showFileAction("updated", "index.js");
+  // 2. Generated files (never overwrite ones the user may have edited).
+  const files = [
+    [path.join(serialDir, "SerialDevice.js"), buildSerialDeviceModule()],
+    [path.join(serialDir, "devices.js"), buildSerialDevicesModule()],
+    [path.join(root, "src", "routes", "serial.js"), buildSerialRouter()],
+    [configFile, "[]\n"],
+  ];
+  for (const [file, content] of files) {
+    if (fs.existsSync(file)) continue;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, content, "utf8");
+    showFileAction("created", path.relative(root, file));
+  }
 
-  const serialportSetup = `
-try {
-  const serialPort = new SerialPort({
-    baudRate: parseInt(process.env.BAUDRATE, 10) || ${baudRate},
-    path: process.env.SERIALPORT_PATH || '${serialPortPath}',
-  });
+  // 3. Wire index.js (idempotent).
+  const before = readIndex();
+  const after = wireSerialIntoIndex(before);
+  if (after !== before) {
+    writeIndex(after);
+    showFileAction("updated", "index.js");
+  }
 
-  const parser = serialPort.pipe(new ReadlineParser({ delimiter: "\\r\\n" }));
+  // 4. Describe the first device, using the boards plugged in right now.
+  console.log();
+  const mod = await import(pathToFileURL(path.join(serialDir, "SerialDevice.js")).href);
+  let ports = [];
+  try {
+    ports = (await mod.listPorts()).filter((p) => p.usb);
+  } catch (e) {
+    showInfo("Could not scan ports (" + e.message + "). You can enter the details by hand.");
+  }
+
+  // Auto-detect: nothing plugged in yet? Wait for a board to appear.
+  if (!ports.length && (await confirm({ message: "No USB serial board found. Wait while you plug one in?", default: true }))) {
+    showInfo("Plug in your board now (waiting up to 60s)…");
+    for (let i = 0; i < 60 && !ports.length; i++) {
+      await new Promise((r) => setTimeout(r, 1000));
+      try {
+        ports = (await mod.listPorts()).filter((p) => p.usb);
+      } catch {}
+    }
+    if (ports.length) showInfo(`Detected ${ports.map((p) => `${p.path} (${p.vendor || p.manufacturer || "unknown chip"})`).join(", ")}`);
+    else showInfo("Still nothing. Check the cable (some are charge-only) and the driver, or enter the details by hand.");
+  }
+
+  let port = null;
+  if (ports.length === 1 && ports[0]) {
+    port = ports[0];
+    showInfo(`Using ${port.path}`);
+  } else if (ports.length) {
+    port = await select({
+      message: "Which board?",
+      choices: [
+        ...ports.map((p) => ({
+          name: `${p.path}  ${p.vendor || p.manufacturer || "unknown chip"}  ${p.vendorId}:${p.productId || "????"}${p.serialNumber ? "  SN " + p.serialNumber : "  (no serial number)"}`,
+          value: p,
+        })),
+        { name: "It's not plugged in / enter details by hand", value: null },
+      ],
+    });
+  }
 
-  parser.on("data", async (data) => {
-    console.log('Received data:', data);
+  const baudRate = await select({
+    message: "Baud rate (must match the firmware's Serial.begin):",
+    default: 115200,
+    choices: SERIAL_BAUD_RATES.map((b) => ({ name: String(b), value: b })),
   });
 
-  serialPort.on("error", function (err) {
-    console.error("SerialPort Error: ", err.message);
+  let identity = null;
+  if (port && (await confirm({ message: `Ask ${port.path} for its identity (sends ID?, resets most boards)?`, default: !port.serialNumber }))) {
+    identity = await mod.probeIdentity(port.path, { baudRate });
+    showInfo(identity ? `Board says: ${identity}` : "No reply to ID?. Check the baud rate and firmware.");
+  }
+
+  const strategy = await select({
+    message: "Find this device by:",
+    default: port && port.serialNumber ? "serialNumber" : identity ? "identity" : port ? "vendorId" : "identity",
+    choices: [
+      { name: "USB serial number (best for identical boards)", value: "serialNumber" },
+      { name: "Firmware identity (reply to ID?)", value: "identity" },
+      { name: "USB vendor id (one board of that type)", value: "vendorId" },
+      { name: "Fixed USB port (last resort: identical boards with no serial number or ID reply)", value: "path" },
+    ],
   });
-} catch (error) {
-  console.error("Error initializing SerialPort:", error);
-}`;
 
-  insertBeforeListen(serialportSetup);
+  const match = {};
+  if (strategy === "serialNumber") {
+    match.serialNumber = await input({ message: "USB serial number:", default: (port && port.serialNumber) || "" });
+  } else if (strategy === "identity") {
+    match.identity = await input({ message: "Reply contains:", default: identity ? identity.split(":")[0] : "" });
+    if (port && port.vendorId) match.vendorId = port.vendorId;
+  } else if (strategy === "vendorId") {
+    match.vendorId = await input({ message: "USB vendor id (4 hex digits):", default: (port && port.vendorId) || "" });
+    if (port && port.productId) match.productId = port.productId;
+  } else {
+    match.path = await input({ message: "Port path:", default: (port && port.path) || (process.platform === "win32" ? "COM3" : "/dev/ttyUSB0") });
+  }
 
-  const projectRoot = getProjectRoot();
-  updateEnvFile(path.join(projectRoot, ".env"), "SERIALPORT_PATH", serialPortPath);
-  updateEnvFile(path.join(projectRoot, ".env"), "BAUDRATE", baudRate);
-  showFileAction("updated", ".env");
+  const name = await input({
+    message: "Device name (used in code and URLs):",
+    default: identity ? identity.split(":")[0].toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/^-+|-+$/g, "") || "device" : "device",
+    validate: (v) => (/^[a-zA-Z][a-zA-Z0-9_-]{0,39}$/.test(v.trim()) ? true : "Start with a letter; letters, numbers, - or _ only."),
+  });
 
-  await installDeps(["serialport", "@serialport/parser-readline"]);
+  const device = normalizeSerialDevice({ name: name.trim(), match, baudRate });
+  const list = (() => {
+    try { const l = JSON.parse(fs.readFileSync(configFile, "utf8")); return Array.isArray(l) ? l : []; } catch { return []; }
+  })().filter((d) => d.name !== device.name);
+  list.push(device);
+  fs.writeFileSync(configFile, JSON.stringify(list, null, 2) + "\n", "utf8");
+  showFileAction("updated", "src/serial/devices.json");
 
-  showTaskDone("SerialPort integration complete", [
-    `Path: ${serialPortPath}`,
-    `Baud rate: ${baudRate}`,
-    "Data logged to console on receive",
+  showTaskDone("Serial device added", [
+    `Device "${device.name}" found by ${Object.entries(device.match).map(([k, v]) => k + "=" + v).join(", ")} at ${device.baudRate} baud`,
+    "Connects at startup and reconnects automatically after a reset or unplug",
+    `HTTP: POST /api/serial/devices/${device.name}/send  {"command": "ID?"}  (needs x-api-key)`,
+    `Code: await getDevice('${device.name}').send('LED:ON')  from ./src/serial/devices.js`,
+    "New boards are detected when plugged in and added automatically (SERIAL_AUTO_ADD=off to disable)",
+    "Manage devices and watch live data in the /_dev dashboard → SerialPort",
   ]);
 }
 

package/index.js

@@ -245,7 +245,7 @@ const addOptions = [
     script: "add-websocket.js",
   },
   {
-    name: "SerialPort           Serial port communication",
+    name: "SerialPort           Arduino/ESP32 devices (auto-detect + reconnect)",
     value: "serialport",
     script: "add-serialport.js",
   },
@@ -255,7 +255,7 @@ const addOptions = [
     script: "add-email.js",
   },
   {
-    name: "Bonjour/mDNS         Advertise this app on the local network",
+    name: "Bonjour/mDNS         Advertise on the LAN (off by default; pick the network)",
     value: "bonjour",
     script: "add-bonjour.js",
   },
@@ -348,7 +348,7 @@ function showHelp() {
   console.log(`  ${c("add security")}        Helmet, rate-limit, RBAC, validation`);
   console.log(`  ${c("add socket")}          Socket.IO integration`);
   console.log(`  ${c("add websocket")}       Native WebSocket support`);
-  console.log(`  ${c("add serialport")}      Serial port communication`);
+  console.log(`  ${c("add serialport")}      Arduino/ESP32 serial devices (auto-detect + reconnect)`);
   console.log(`  ${c("add email")}           Transactional email (Brevo, SendGrid, SMTP)`);
   console.log(`  ${c("add bonjour")}         Advertise on the local network (Bonjour/mDNS)`);
   console.log();