daemora 1.0.2 → 1.0.3

package/src/tools/screenCapture.js

@@ -1,9 +1,9 @@
 /**
- * screenCapture(optionsJson?) — Take a screenshot or record a screen video.
+ * screenCapture(optionsJson?) - Take a screenshot or record a screen video.
  *
  * Modes:
- *   screenshot (default) — single still image (PNG)
- *   video                — screen recording (MP4), uses `duration` seconds (default 10)
+ *   screenshot (default) - single still image (PNG)
+ *   video                - screen recording (MP4), uses `duration` seconds (default 10)
  *
  * macOS: uses built-in `screencapture` command.
  * Linux: screenshots via ImageMagick/gnome-screenshot/scrot; video via ffmpeg.
@@ -20,9 +20,9 @@ export function screenCapture(optionsJson) {
   try {
     const opts = optionsJson ? JSON.parse(optionsJson) : {};
     const outputDir = opts.outputDir || "/tmp";
-    const region    = opts.region;                   // { x, y, width, height } — screenshot only
+    const region    = opts.region;                   // { x, y, width, height } - screenshot only
     const mode      = (opts.mode || "screenshot").toLowerCase();
-    const duration  = parseInt(opts.duration || "10", 10); // seconds — video only
+    const duration  = parseInt(opts.duration || "10", 10); // seconds - video only
 
     if (!existsSync(outputDir)) {
       mkdirSync(outputDir, { recursive: true });
@@ -106,7 +106,7 @@ export function screenCapture(optionsJson) {
 }
 
 export const screenCaptureDescription =
-  'screenCapture(optionsJson?) — Capture a screenshot or record a screen video. ' +
+  'screenCapture(optionsJson?) - Capture a screenshot or record a screen video. ' +
   'optionsJson: {"mode":"screenshot"|"video","outputDir":"/tmp","duration":10,"region":{"x":0,"y":0,"width":800,"height":600}}. ' +
   'mode defaults to "screenshot". duration (seconds) only applies to video mode. ' +
   'Returns the file path. Chain with imageAnalysis to analyze screenshots, or sendFile to deliver to user.';

package/src/tools/searchContent.js

@@ -1,5 +1,5 @@
 /**
- * searchContent(pattern, directory?, optionsJson?) — Search file contents.
+ * searchContent(pattern, directory?, optionsJson?) - Search file contents.
  * Upgraded: context lines, case-insensitive, file type filter, extended regex support.
  */
 import { execSync } from "node:child_process";
@@ -63,7 +63,7 @@ export function searchContent(pattern, directory = ".", optionsJson) {
     }
 
     const lines = trimmed.split("\n");
-    const suffix = lines.length >= limit ? ` (limit: ${limit}, may have more — increase with optionsJson {"limit":200})` : "";
+    const suffix = lines.length >= limit ? ` (limit: ${limit}, may have more - increase with optionsJson {"limit":200})` : "";
     console.log(`      [searchContent] Found ${lines.length} match(es)`);
     return `Found ${lines.length} match(es) for "${pattern}"${suffix}:\n\n${trimmed}`;
   } catch (error) {

package/src/tools/searchFiles.js

@@ -1,5 +1,5 @@
 /**
- * searchFiles(pattern, directory?, optionsJson?) — Find files by name pattern.
+ * searchFiles(pattern, directory?, optionsJson?) - Find files by name pattern.
  * Upgraded: modification time sorting, depth control, size filters.
  */
 import { execSync } from "node:child_process";

package/src/tools/sendEmail.js

@@ -1,8 +1,16 @@
 /**
- * Send Email — sends email via SMTP (nodemailer).
- * Upgraded: CC/BCC, attachments, replyTo, email validation, optionsJson support.
+ * Send Email - sends email via SMTP or Resend (nodemailer).
+ *
+ * Credential resolution order (first match wins):
+ *   1. Per-tenant channel config  (daemora tenant channel set <id> resend_api_key ...)
+ *   2. Global .env                (RESEND_API_KEY / EMAIL_USER + EMAIL_PASSWORD)
+ *
+ * This means each tenant can use their own email credentials without affecting others.
+ * Concurrent requests are safe — tenant credentials are never written to process.env.
  */
 
+import tenantContext from "../tenants/TenantContext.js";
+
 const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
 
 function validateEmail(addr) {
@@ -14,29 +22,76 @@ function parseAddressList(val) {
   return val.split(",").map((a) => a.trim()).filter(Boolean);
 }
 
-let transporter = null;
+// Module-level singleton for global (non-tenant) SMTP — reused across requests for performance.
+// Tenant-specific transporters are always fresh (never cached) to avoid cross-tenant bleed.
+let _globalTransporter = null;
 
 async function getTransporter() {
-  if (transporter) return transporter;
+  const store = tenantContext.getStore();
+  const ch = store?.resolvedConfig?.channelConfig || {};
 
-  const user = process.env.EMAIL_USER;
-  const pass = process.env.EMAIL_PASSWORD;
-  const host = process.env.EMAIL_SMTP_HOST || "smtp.gmail.com";
-  const port = parseInt(process.env.EMAIL_SMTP_PORT || "587", 10);
+  // Resolve credentials: tenant config > global env
+  const resendKey  = ch.resend_api_key  || process.env.RESEND_API_KEY  || null;
+  const resendFrom = ch.resend_from     || process.env.RESEND_FROM     || null;
+  const smtpUser   = ch.email           || process.env.EMAIL_USER       || null;
+  const smtpPass   = ch.email_password  || process.env.EMAIL_PASSWORD   || null;
+  const smtpHost   = process.env.EMAIL_SMTP_HOST || "smtp.gmail.com";
+  const smtpPort   = parseInt(process.env.EMAIL_SMTP_PORT || "587", 10);
 
-  if (!user || !pass) {
-    return null;
-  }
+  if (!resendKey && !smtpUser) return { transporter: null, from: null };
 
   const nodemailer = await import("nodemailer");
-  transporter = nodemailer.default.createTransport({
-    host,
-    port,
-    secure: port === 465,
-    auth: { user, pass },
-  });
-
-  return transporter;
+  const hasTenantCreds = !!(ch.resend_api_key || ch.email);
+
+  if (hasTenantCreds) {
+    // Tenant-specific: always create a fresh transporter (never cache — different per tenant)
+    if (resendKey) {
+      return {
+        transporter: nodemailer.default.createTransport({
+          host: "smtp.resend.com",
+          port: 465,
+          secure: true,
+          auth: { user: "resend", pass: resendKey },
+        }),
+        from: resendFrom || `daemora@resend.dev`,
+      };
+    }
+    return {
+      transporter: nodemailer.default.createTransport({
+        host: smtpHost,
+        port: smtpPort,
+        secure: smtpPort === 465,
+        auth: { user: smtpUser, pass: smtpPass },
+      }),
+      from: smtpUser,
+    };
+  }
+
+  // Global config: use singleton cache
+  if (!_globalTransporter) {
+    if (resendKey) {
+      _globalTransporter = {
+        transporter: nodemailer.default.createTransport({
+          host: "smtp.resend.com",
+          port: 465,
+          secure: true,
+          auth: { user: "resend", pass: resendKey },
+        }),
+        from: resendFrom || `daemora@resend.dev`,
+      };
+    } else {
+      _globalTransporter = {
+        transporter: nodemailer.default.createTransport({
+          host: smtpHost,
+          port: smtpPort,
+          secure: smtpPort === 465,
+          auth: { user: smtpUser, pass: smtpPass },
+        }),
+        from: smtpUser,
+      };
+    }
+  }
+  return _globalTransporter;
 }
 
 export async function sendEmail(to, subject, body, optionsJson) {
@@ -53,7 +108,7 @@ export async function sendEmail(to, subject, body, optionsJson) {
   const cc = opts.cc ? parseAddressList(opts.cc) : null;
   const bcc = opts.bcc ? parseAddressList(opts.bcc) : null;
   const replyTo = opts.replyTo || null;
-  const attachments = Array.isArray(opts.attachments) ? opts.attachments : null; // [{filename, path}]
+  const attachments = Array.isArray(opts.attachments) ? opts.attachments : null;
 
   // Validate addresses
   const toList = parseAddressList(to);
@@ -74,14 +129,14 @@ export async function sendEmail(to, subject, body, optionsJson) {
 
   console.log(`      [sendEmail] To: ${to} | Subject: "${subject}"${cc ? ` | CC: ${cc.join(",")}` : ""}${bcc ? ` | BCC: ${bcc.join(",")}` : ""}`);
 
-  const smtp = await getTransporter();
+  const { transporter: smtp, from } = await getTransporter();
   if (!smtp) {
-    return "Error: Email not configured. Set EMAIL_USER and EMAIL_PASSWORD in .env";
+    return "Error: Email not configured. Set RESEND_API_KEY or EMAIL_USER+EMAIL_PASSWORD in .env, or use: daemora tenant channel set <id> resend_api_key <key>";
   }
 
   try {
     const mailOptions = {
-      from: process.env.EMAIL_USER,
+      from,
       to: toList.join(", "),
       subject,
       text: body,
@@ -115,4 +170,4 @@ export async function sendEmail(to, subject, body, optionsJson) {
 }
 
 export const sendEmailDescription =
-  'sendEmail(to: string, subject: string, body: string, optionsJson?: string) - Send email via SMTP. optionsJson: {"cc":"a@b.com,c@d.com","bcc":"e@f.com","replyTo":"r@s.com","attachments":[{"filename":"report.pdf","path":"/tmp/report.pdf"}]}. Requires EMAIL_USER + EMAIL_PASSWORD in .env.';
+  'sendEmail(to: string, subject: string, body: string, optionsJson?: string) - Send email. Uses per-tenant channel config if set (daemora tenant channel set), otherwise falls back to global RESEND_API_KEY or EMAIL_USER+EMAIL_PASSWORD. optionsJson: {"cc":"a@b.com","bcc":"e@f.com","replyTo":"r@s.com","attachments":[{"filename":"report.pdf","path":"/tmp/report.pdf"}]}';

package/src/tools/sendFile.js

@@ -1,5 +1,5 @@
 /**
- * sendFile(channel, target, filePath, caption?) — Send a file/image/video to a user on any channel.
+ * sendFile(channel, target, filePath, caption?) - Send a file/image/video to a user on any channel.
  *
  * The agent uses this to proactively deliver:
  * - Screenshots it captured (screenCapture → sendFile)
@@ -9,14 +9,14 @@
  * - Any other file the user should receive
  *
  * channel: "telegram" | "discord" | "slack" | "whatsapp" | "email"
- * target:  chat ID, user ID, channel ID, phone number, or email — depends on channel
+ * target:  chat ID, user ID, channel ID, phone number, or email - depends on channel
  * filePath: absolute path to the local file to send
  * caption: optional text caption alongside the file
  */
 import channelRegistry from "../channels/index.js";
 import { existsSync, statSync } from "node:fs";
 
-const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50 MB — most platforms limit around this
+const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50 MB - most platforms limit around this
 
 export async function sendFile(channel, target, filePath, caption) {
   try {
@@ -56,7 +56,7 @@ export async function sendFile(channel, target, filePath, caption) {
 }
 
 export const sendFileDescription =
-  'sendFile(channel, target, filePath, caption?) — Send a file, image, or video to a user. ' +
+  'sendFile(channel, target, filePath, caption?) - Send a file, image, or video to a user. ' +
   'channel: "telegram"|"discord"|"slack"|"email". ' +
   'target: chat ID (Telegram), user/channel ID (Discord/Slack), or email. ' +
   'filePath: absolute path to the file. caption: optional text alongside the file. ' +

package/src/tools/sonos.js

@@ -0,0 +1,137 @@
+/**
+ * sonos - Control Sonos speakers via local network API.
+ * Uses the Sonos UPNP/SOAP API or the newer Sonos Control API (cloud).
+ * Local control (no cloud): sends SOAP requests to speaker IP on port 1400.
+ * Requires SONOS_SPEAKER_IP or uses discovery.
+ */
+
+const SONOS_PORT = 1400;
+
+async function sonosSoap(speakerIp, service, action, body = "") {
+  const fetchFn = globalThis.fetch || (await import("node-fetch")).default;
+  const serviceMap = {
+    "AVTransport": { path: "/MediaRenderer/AVTransport/Control", xmlns: "urn:schemas-upnp-org:service:AVTransport:1" },
+    "RenderingControl": { path: "/MediaRenderer/RenderingControl/Control", xmlns: "urn:schemas-upnp-org:service:RenderingControl:1" },
+    "ZoneGroupTopology": { path: "/ZoneGroupTopology/Control", xmlns: "urn:schemas-upnp-org:service:ZoneGroupTopology:1" },
+  };
+
+  const svc = serviceMap[service];
+  if (!svc) throw new Error(`Unknown service: ${service}`);
+
+  const envelope = `<?xml version="1.0"?><s:Envelope xmlns:s="http://schemas.xmlsoap.org/soap/envelope/" s:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><s:Body><u:${action} xmlns:u="${svc.xmlns}">${body}</u:${action}></s:Body></s:Envelope>`;
+
+  const res = await fetchFn(`http://${speakerIp}:${SONOS_PORT}${svc.path}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "text/xml; charset=utf-8",
+      "SOAPAction": `"${svc.xmlns}#${action}"`,
+    },
+    body: envelope,
+  });
+
+  const text = await res.text();
+  if (!res.ok) throw new Error(`SOAP error ${res.status}: ${text.slice(0, 200)}`);
+  return text;
+}
+
+export async function sonos(action, paramsJson) {
+  if (!action) return "Error: action required. Valid: play, pause, stop, next, prev, volume, mute, queue, info";
+  const params = paramsJson
+    ? (typeof paramsJson === "string" ? JSON.parse(paramsJson) : paramsJson)
+    : {};
+
+  const speakerIp = params.speakerIp || process.env.SONOS_SPEAKER_IP;
+  if (!speakerIp) return "Error: SONOS_SPEAKER_IP env var or speakerIp param required";
+
+  try {
+    if (action === "play") {
+      await sonosSoap(speakerIp, "AVTransport", "Play", "<InstanceID>0</InstanceID><Speed>1</Speed>");
+      return "Playback started";
+    }
+
+    if (action === "pause") {
+      await sonosSoap(speakerIp, "AVTransport", "Pause", "<InstanceID>0</InstanceID>");
+      return "Playback paused";
+    }
+
+    if (action === "stop") {
+      await sonosSoap(speakerIp, "AVTransport", "Stop", "<InstanceID>0</InstanceID>");
+      return "Playback stopped";
+    }
+
+    if (action === "next") {
+      await sonosSoap(speakerIp, "AVTransport", "Next", "<InstanceID>0</InstanceID>");
+      return "Skipped to next track";
+    }
+
+    if (action === "prev" || action === "previous") {
+      await sonosSoap(speakerIp, "AVTransport", "Previous", "<InstanceID>0</InstanceID>");
+      return "Went to previous track";
+    }
+
+    if (action === "volume") {
+      const { level } = params;
+      if (level === undefined) {
+        // Get current volume
+        const xml = await sonosSoap(speakerIp, "RenderingControl", "GetVolume",
+          "<InstanceID>0</InstanceID><Channel>Master</Channel>");
+        const match = xml.match(/<CurrentVolume>(\d+)<\/CurrentVolume>/);
+        return `Current volume: ${match?.[1] || "unknown"}`;
+      }
+      const vol = Math.max(0, Math.min(100, Math.round(level)));
+      await sonosSoap(speakerIp, "RenderingControl", "SetVolume",
+        `<InstanceID>0</InstanceID><Channel>Master</Channel><DesiredVolume>${vol}</DesiredVolume>`);
+      return `Volume set to ${vol}`;
+    }
+
+    if (action === "mute") {
+      const muted = params.muted !== false; // default true (mute)
+      await sonosSoap(speakerIp, "RenderingControl", "SetMute",
+        `<InstanceID>0</InstanceID><Channel>Master</Channel><DesiredMute>${muted ? "1" : "0"}</DesiredMute>`);
+      return muted ? "Speaker muted" : "Speaker unmuted";
+    }
+
+    if (action === "info") {
+      const xml = await sonosSoap(speakerIp, "AVTransport", "GetTransportInfo", "<InstanceID>0</InstanceID>");
+      const stateMatch = xml.match(/<CurrentTransportState>([^<]+)<\/CurrentTransportState>/);
+
+      const posXml = await sonosSoap(speakerIp, "AVTransport", "GetPositionInfo", "<InstanceID>0</InstanceID>");
+      const trackMatch = posXml.match(/<TrackURI>([^<]*)<\/TrackURI>/);
+      const metaMatch = posXml.match(/<TrackMetaData>([^<]*)<\/TrackMetaData>/);
+
+      const lines = [
+        `State: ${stateMatch?.[1] || "unknown"}`,
+        trackMatch?.[1] ? `Track: ${decodeURIComponent(trackMatch[1]).split("/").pop()}` : "",
+      ].filter(Boolean);
+      return lines.join("\n");
+    }
+
+    if (action === "queue") {
+      const { uri, title } = params;
+      if (!uri) return "Error: uri required to queue a track (e.g. spotify URI or HTTP stream URL)";
+      await sonosSoap(speakerIp, "AVTransport", "SetAVTransportURI",
+        `<InstanceID>0</InstanceID><CurrentURI>${uri}</CurrentURI><CurrentURIMetaData>${title ? `<DIDL-Lite xmlns="urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/"><item id="-1" parentID="-1" restricted="true"><dc:title xmlns:dc="http://purl.org/dc/elements/1.1/">${title}</dc:title></item></DIDL-Lite>` : ""}</CurrentURIMetaData>`);
+      return `Queued: ${title || uri}`;
+    }
+
+  } catch (err) {
+    return `Sonos error: ${err.message}`;
+  }
+
+  return `Unknown action: "${action}". Valid: play, pause, stop, next, prev, volume, mute, queue, info`;
+}
+
+export const sonosDescription =
+  `sonos(action: string, paramsJson?: object) - Control Sonos speakers via local network.
+  action: "play" | "pause" | "stop" | "next" | "prev" | "volume" | "mute" | "queue" | "info"
+  play/pause/stop/next/prev: { speakerIp? }
+  volume: { level?: 0-100, speakerIp? } (omit level to get current volume)
+  mute: { muted?: true, speakerIp? }
+  queue: { uri: "spotify:track:...|http://...", title?, speakerIp? }
+  info: { speakerIp? } → playback state + current track
+  Env var: SONOS_SPEAKER_IP
+  Examples:
+    sonos("play")
+    sonos("volume", {"level":40})
+    sonos("info")
+    sonos("queue", {"uri":"x-sonosapi-stream:s95362?sid=254","title":"Radio"})`;

package/src/tools/sshTool.js

@@ -0,0 +1,130 @@
+/**
+ * sshTool - Execute commands on remote servers via SSH.
+ * Uses child_process to call the system ssh binary.
+ * Supports password auth (via sshpass) and key-based auth.
+ * Security: commands are passed as arguments (not shell-interpolated).
+ */
+import { execFileSync } from "node:child_process";
+import { writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomBytes } from "node:crypto";
+
+export async function sshTool(action, paramsJson) {
+  if (!action) return "Error: action required. Valid: exec, upload, download, tunnel";
+  const params = paramsJson
+    ? (typeof paramsJson === "string" ? JSON.parse(paramsJson) : paramsJson)
+    : {};
+
+  const {
+    host,
+    user = "root",
+    port = 22,
+    keyPath = null,
+    timeout = 30,
+  } = params;
+
+  if (!host) return "Error: host is required";
+
+  // Build ssh base args
+  const baseArgs = [
+    "-o", "StrictHostKeyChecking=no",
+    "-o", "BatchMode=yes",
+    "-o", `ConnectTimeout=${timeout}`,
+    "-p", String(port),
+    ...(keyPath ? ["-i", keyPath] : []),
+    `${user}@${host}`,
+  ];
+
+  if (action === "exec") {
+    const { command } = params;
+    if (!command) return "Error: command is required for exec";
+
+    // Security: command is passed as a string to ssh (executed via remote shell)
+    // We don't shell-interpolate it locally
+    try {
+      const out = execFileSync("ssh", [...baseArgs, command], {
+        encoding: "utf-8",
+        timeout: timeout * 1000,
+        maxBuffer: 10 * 1024 * 1024,
+      });
+      return out.trim() || "(command produced no output)";
+    } catch (err) {
+      const msg = err.stderr?.trim() || err.message;
+      return `SSH exec error: ${msg}`;
+    }
+  }
+
+  if (action === "upload") {
+    const { localPath, remotePath } = params;
+    if (!localPath || !remotePath) return "Error: localPath and remotePath required for upload";
+
+    const scpArgs = [
+      "-o", "StrictHostKeyChecking=no",
+      "-P", String(port),
+      ...(keyPath ? ["-i", keyPath] : []),
+      localPath,
+      `${user}@${host}:${remotePath}`,
+    ];
+
+    try {
+      execFileSync("scp", scpArgs, { encoding: "utf-8", timeout: timeout * 1000 });
+      return `Uploaded ${localPath} → ${user}@${host}:${remotePath}`;
+    } catch (err) {
+      return `SCP upload error: ${err.stderr?.trim() || err.message}`;
+    }
+  }
+
+  if (action === "download") {
+    const { remotePath, localPath } = params;
+    if (!remotePath || !localPath) return "Error: remotePath and localPath required for download";
+
+    const scpArgs = [
+      "-o", "StrictHostKeyChecking=no",
+      "-P", String(port),
+      ...(keyPath ? ["-i", keyPath] : []),
+      `${user}@${host}:${remotePath}`,
+      localPath,
+    ];
+
+    try {
+      execFileSync("scp", scpArgs, { encoding: "utf-8", timeout: timeout * 1000 });
+      return `Downloaded ${user}@${host}:${remotePath} → ${localPath}`;
+    } catch (err) {
+      return `SCP download error: ${err.stderr?.trim() || err.message}`;
+    }
+  }
+
+  if (action === "keygen") {
+    // Generate a new SSH key pair for the agent's use
+    const keyDir = join(tmpdir(), `daemora-ssh-${randomBytes(4).toString("hex")}`);
+    mkdirSync(keyDir, { recursive: true });
+    const keyFile = join(keyDir, "id_ed25519");
+    try {
+      execFileSync("ssh-keygen", ["-t", "ed25519", "-C", "daemora-agent", "-f", keyFile, "-N", ""], {
+        encoding: "utf-8",
+        timeout: 10000,
+      });
+      const { readFileSync } = await import("node:fs");
+      const pub = readFileSync(`${keyFile}.pub`, "utf-8").trim();
+      return `SSH key pair generated:\nPrivate key: ${keyFile}\nPublic key: ${pub}`;
+    } catch (err) {
+      return `ssh-keygen error: ${err.message}`;
+    }
+  }
+
+  return `Unknown action: "${action}". Valid: exec, upload, download, keygen`;
+}
+
+export const sshToolDescription =
+  `sshTool(action: string, paramsJson?: object) - Execute commands or transfer files over SSH.
+  action: "exec" | "upload" | "download" | "keygen"
+  exec params: { host, user?, port?, keyPath?, command, timeout? }
+  upload params: { host, user?, port?, keyPath?, localPath, remotePath }
+  download params: { host, user?, port?, keyPath?, remotePath, localPath }
+  keygen: generates a new ed25519 SSH key pair (no params needed)
+  Note: Uses system ssh/scp binaries. StrictHostKeyChecking disabled for agent use.
+  Examples:
+    sshTool("exec", {"host":"192.168.1.10","user":"ubuntu","command":"df -h"})
+    sshTool("upload", {"host":"server.com","localPath":"/tmp/file.txt","remotePath":"/home/user/file.txt"})
+    sshTool("exec", {"host":"prod.example.com","keyPath":"~/.ssh/id_ed25519","command":"systemctl status nginx"})`;

package/src/tools/textToSpeech.js

@@ -1,7 +1,7 @@
 /**
- * textToSpeech(text, optionsJson?) — Convert text to speech and save as audio file.
+ * textToSpeech(text, optionsJson?) - Convert text to speech and save as audio file.
  *
- * Primary:  OpenAI TTS (tts-1-hd) — uses the same OPENAI_API_KEY already configured.
+ * Primary:  OpenAI TTS (tts-1-hd) - uses the same OPENAI_API_KEY already configured.
  * Optional: ElevenLabs via ELEVENLABS_API_KEY (higher quality, more voices).
  *
  * Unlike OpenClaw's /voice command (config-only, iOS-only), this is a proper
@@ -68,7 +68,7 @@ async function _openAI(text, opts) {
     return `Audio saved to: ${filePath}`;
   }
 
-  // Multiple chunks — save each sequentially, return all paths
+  // Multiple chunks - save each sequentially, return all paths
   const paths = [];
   for (let i = 0; i < chunks.length; i++) {
     const response = await client.audio.speech.create({ model, voice, input: chunks[i], speed, response_format: format });
@@ -88,7 +88,7 @@ async function _elevenLabs(text, opts) {
     return "Error: provider=elevenlabs requires ELEVENLABS_API_KEY";
   }
 
-  // Default: Rachel — professional female voice, works well for most content
+  // Default: Rachel - professional female voice, works well for most content
   const voiceId  = opts.voiceId  || "21m00Tcm4TlvDq8ikWAM";
   const modelId  = opts.modelId  || "eleven_multilingual_v2"; // supports 29 languages
   const stability       = parseFloat(opts.stability       || "0.5");
@@ -155,7 +155,7 @@ function _splitText(text, maxLength) {
 }
 
 export const textToSpeechDescription =
-  'textToSpeech(text: string, optionsJson?: string) — Convert text to an audio file using OpenAI TTS (default) or ElevenLabs. ' +
+  'textToSpeech(text: string, optionsJson?: string) - Convert text to an audio file using OpenAI TTS (default) or ElevenLabs. ' +
   'optionsJson: {"voice":"nova|alloy|echo|fable|onyx|shimmer","speed":1.0,"format":"mp3","hd":true,"provider":"openai|elevenlabs","voiceId":"<elevenlabs-id>"}. ' +
   'Requires OPENAI_API_KEY (or ELEVENLABS_API_KEY for ElevenLabs). ' +
   'Auto-splits long texts. Returns the saved file path. Chain with sendFile() to deliver audio to the user.';

package/src/tools/transcribeAudio.js

@@ -1,5 +1,5 @@
 /**
- * transcribeAudio(audioPath, prompt?) — Transcribe audio/voice files to text using OpenAI Whisper.
+ * transcribeAudio(audioPath, prompt?) - Transcribe audio/voice files to text using OpenAI Whisper.
  *
  * Supports: local file paths and HTTPS URLs.
  * Formats: mp3, mp4, mpeg, mpga, m4a, wav, webm, ogg, oga, flac
@@ -16,7 +16,7 @@ const SUPPORTED_EXTENSIONS = new Set([
   ".mp3", ".mp4", ".mpeg", ".mpga", ".m4a", ".wav", ".webm", ".ogg", ".oga", ".flac"
 ]);
 
-// Telegram voices come as .oga (ogg audio) — map to .ogg for Whisper compatibility
+// Telegram voices come as .oga (ogg audio) - map to .ogg for Whisper compatibility
 const EXT_REMAP = { ".oga": ".ogg" };
 
 export async function transcribeAudio(audioPath, prompt) {
@@ -70,7 +70,7 @@ export async function transcribeAudio(audioPath, prompt) {
       ? transcription.trim()
       : (transcription.text || "").trim();
 
-    if (!text) return "Transcription returned empty — audio may be silent or too short.";
+    if (!text) return "Transcription returned empty - audio may be silent or too short.";
     return text;
 
   } catch (error) {
@@ -79,4 +79,4 @@ export async function transcribeAudio(audioPath, prompt) {
 }
 
 export const transcribeAudioDescription =
-  'transcribeAudio(audioPath: string, prompt?: string) — Transcribe a voice/audio file to text using OpenAI Whisper. audioPath: local file path or HTTPS URL. Formats: mp3, mp4, m4a, wav, webm, ogg, flac. Requires OPENAI_API_KEY.';
+  'transcribeAudio(audioPath: string, prompt?: string) - Transcribe a voice/audio file to text using OpenAI Whisper. audioPath: local file path or HTTPS URL. Formats: mp3, mp4, m4a, wav, webm, ogg, flac. Requires OPENAI_API_KEY.';

package/src/tools/useMCP.js

@@ -2,13 +2,13 @@ import { runMCPAgent } from "../mcp/MCPAgentRunner.js";
 import tenantContext from "../tenants/TenantContext.js";
 
 /**
- * useMCP — delegate a task to a specialist agent for a specific MCP server.
+ * useMCP - delegate a task to a specialist agent for a specific MCP server.
  *
  * The specialist agent receives ONLY that server's tools and a focused system prompt.
  * This keeps context lean: main agent stays uncluttered, specialist stays focused.
  *
  * @param {string} serverName       - MCP server name (e.g. "github", "notion", "slack")
- * @param {string} taskDescription  - Full task spec — the agent has no other context
+ * @param {string} taskDescription  - Full task spec - the agent has no other context
  * @returns {Promise<string>}       - Specialist agent's final response
  */
 export async function useMCP(serverName, taskDescription) {
@@ -25,5 +25,5 @@ export async function useMCP(serverName, taskDescription) {
 export const useMCPDescription =
   `useMCP(serverName: string, taskDescription: string) - Delegate a task to a specialist MCP agent for the named server.
   - serverName: the MCP server to use (use manageMCP("list") to see available servers)
-  - taskDescription: comprehensive task spec — the specialist has no other context, so include all details
-  - The specialist gets ONLY that server's tools — lean context, no confusion with built-in tools`;
+  - taskDescription: comprehensive task spec - the specialist has no other context, so include all details
+  - The specialist gets ONLY that server's tools - lean context, no confusion with built-in tools`;

package/src/tools/webFetch.js

@@ -1,11 +1,11 @@
 /**
- * webFetch(url, optionsJson?) — Fetch URL content with proper HTML conversion, caching, and SSRF protection.
+ * webFetch(url, optionsJson?) - Fetch URL content with proper HTML conversion, caching, and SSRF protection.
  * Upgraded: html-to-text library, 15-min cache, SSRF guard, 50K char limit, GitHub URL conversion.
  */
 import { convert } from "html-to-text";
 import { URL } from "node:url";
 
-// Private IP ranges — SSRF protection
+// Private IP ranges - SSRF protection
 const PRIVATE_RANGES = [
   /^127\./,
   /^10\./,

package/src/tools/webSearch.js

@@ -1,5 +1,5 @@
 /**
- * Web Search — DuckDuckGo (free) + Brave Search (if API key set).
+ * Web Search - DuckDuckGo (free) + Brave Search (if API key set).
  * Upgraded: result caching, freshness/date filters, optionsJson support.
  */