@openenthrium/oe-runtime-sdk 1.7.5

package/src/utils/tools/adapters/sftp.js

@@ -0,0 +1,121 @@
+const { Client } = require("ssh2");
+
+function getConfig(connector) {
+  const auth = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  const cfg  = connector.config     ? JSON.parse(connector.config)     : {};
+  return {
+    host:       auth.host       || cfg.host       || "localhost",
+    port:       parseInt(auth.port || cfg.port || "22"),
+    username:   auth.username   || cfg.username   || "root",
+    password:   auth.password   || cfg.password   || undefined,
+    privateKey: auth.privateKey || cfg.privateKey || undefined,
+    passphrase: auth.passphrase || cfg.passphrase || undefined,
+  };
+}
+
+function withSftp(cfg, fn) {
+  return new Promise((resolve, reject) => {
+    const conn = new Client();
+    conn.on("ready", () => {
+      conn.sftp((err, sftp) => {
+        if (err) { conn.end(); return reject(err); }
+        Promise.resolve(fn(sftp))
+          .then(r => { conn.end(); resolve(r); })
+          .catch(e => { conn.end(); reject(e); });
+      });
+    });
+    conn.on("error", reject);
+    const connectCfg = { host: cfg.host, port: cfg.port, username: cfg.username };
+    if (cfg.privateKey) { connectCfg.privateKey = cfg.privateKey; if (cfg.passphrase) connectCfg.passphrase = cfg.passphrase; }
+    else if (cfg.password) connectCfg.password = cfg.password;
+    conn.connect(connectCfg);
+  });
+}
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_list`,
+        description: `List files and directories on the SFTP server "${connector.name}".`,
+        parameters: { type: "object", properties: { path: { type: "string", description: "Remote directory path (default: /)" } }, required: [] },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_read`,
+        description: `Read a text file from the SFTP server "${connector.name}".`,
+        parameters: { type: "object", properties: { path: { type: "string", description: "Full remote file path" } }, required: ["path"] },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_write`,
+        description: `Write content to a file on the SFTP server "${connector.name}".`,
+        parameters: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_delete`,
+        description: `Delete a file on the SFTP server "${connector.name}".`,
+        parameters: { type: "object", properties: { path: { type: "string" } }, required: ["path"] },
+      },
+    },
+  ];
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return getToolDefinitions(connector).map(t => ({
+    name: t.function.name,
+    description: t.function.description,
+    input_schema: t.function.parameters,
+  }));
+}
+
+async function executeTool(action, args, connector) {
+  const cfg = getConfig(connector);
+  if (!cfg.password && !cfg.privateKey) return "SFTP not configured: provide password or privateKey.";
+
+  try {
+    if (action === "list") {
+      return await withSftp(cfg, sftp => new Promise((res, rej) => {
+        sftp.readdir(args.path || "/", (err, list) => {
+          if (err) return rej(err);
+          res(list.map(f => `${f.longname}`).join("\n"));
+        });
+      }));
+    }
+    if (action === "read") {
+      return await withSftp(cfg, sftp => new Promise((res, rej) => {
+        const chunks = [];
+        const stream = sftp.createReadStream(args.path);
+        stream.on("data", d => chunks.push(d));
+        stream.on("end", () => res(Buffer.concat(chunks).toString("utf8").slice(0, 8000)));
+        stream.on("error", rej);
+      }));
+    }
+    if (action === "write") {
+      return await withSftp(cfg, sftp => new Promise((res, rej) => {
+        const stream = sftp.createWriteStream(args.path);
+        stream.on("close", () => res(`Written: ${args.path}`));
+        stream.on("error", rej);
+        stream.end(args.content || "");
+      }));
+    }
+    if (action === "delete") {
+      return await withSftp(cfg, sftp => new Promise((res, rej) => {
+        sftp.unlink(args.path, err => err ? rej(err) : res(`Deleted: ${args.path}`));
+      }));
+    }
+    return `Unknown SFTP action: ${action}`;
+  } catch (err) {
+    return `SFTP error: ${err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

package/src/utils/tools/adapters/shell.js

@@ -0,0 +1,97 @@
+"use strict";
+
+const { exec }  = require("child_process");
+const path      = require("path");
+const os        = require("os");
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function getConfig(connector) {
+  const auth   = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  const config = connector.config     ? JSON.parse(connector.config)     : {};
+  return {
+    cwd:     auth.cwd     || config.cwd     || process.cwd(),
+    timeout: parseInt(auth.timeout || config.timeout || "30"),
+    shell:   auth.shell   || config.shell   || (os.platform() === "win32" ? "cmd" : "bash"),
+  };
+}
+
+function runCommand(command, cfg) {
+  const timeoutMs = Math.min(cfg.timeout, 300) * 1000;
+  const cwd = path.resolve(cfg.cwd);
+  const shellOpt = cfg.shell === "cmd"
+    ? { shell: "cmd.exe" }
+    : { shell: cfg.shell === "sh" ? "/bin/sh" : "/bin/bash" };
+
+  return new Promise((resolve) => {
+    exec(command, { cwd, timeout: timeoutMs, maxBuffer: 1024 * 1024 * 4, ...shellOpt }, (err, stdout, stderr) => {
+      if (err && err.killed) {
+        resolve({ stdout: stdout || "", stderr: stderr || "", exit_code: -1, error: `Command timed out after ${cfg.timeout}s` });
+      } else {
+        resolve({ stdout: stdout || "", stderr: stderr || "", exit_code: err ? (err.code ?? 1) : 0 });
+      }
+    });
+  });
+}
+
+function formatResult({ stdout, stderr, exit_code, error }) {
+  const parts = [];
+  if (error)               parts.push(`Error: ${error}`);
+  if (stdout.trim())       parts.push(stdout.trim());
+  if (stderr.trim())       parts.push(`STDERR:\n${stderr.trim()}`);
+  parts.push(`exit_code: ${exit_code}`);
+  return parts.join("\n\n").slice(0, 8000);
+}
+
+// ─── Tool definitions ─────────────────────────────────────────────────────────
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name:        `conn_${connector.id}_exec`,
+        description: `Run a shell command on the local machine (${connector.name}). Use to execute Python, PHP, Node.js, Java, Bash scripts or any installed CLI tool. Returns stdout, stderr, and exit code.`,
+        parameters: {
+          type:       "object",
+          properties: {
+            command: { type: "string", description: "The shell command to run (e.g. 'python3 script.py --arg value')." },
+            cwd:     { type: "string", description: "Working directory override. Defaults to the cwd set in oe-config.json." },
+            timeout: { type: "number", description: "Timeout in seconds (default from config, max 300)." },
+          },
+          required: ["command"],
+        },
+      },
+    },
+  ];
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return getToolDefinitions(connector).map(t => ({
+    name:         t.function.name,
+    description:  t.function.description,
+    input_schema: t.function.parameters,
+  }));
+}
+
+// ─── Execute ──────────────────────────────────────────────────────────────────
+
+async function executeTool(action, args, connector) {
+  if (action !== "exec") return `Unknown shell action: ${action}`;
+
+  const { command, cwd: cwdOverride, timeout: timeoutOverride } = args;
+  if (!command) return "Missing required field: command.";
+
+  const cfg = getConfig(connector);
+  if (cwdOverride)     cfg.cwd     = cwdOverride;
+  if (timeoutOverride) cfg.timeout = Math.min(parseInt(timeoutOverride), 300);
+
+  try {
+    const result = await runCommand(command, cfg);
+    return formatResult(result);
+  } catch (err) {
+    return `Shell error: ${err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

package/src/utils/tools/adapters/slack.js

@@ -0,0 +1,83 @@
+const axios = require("axios");
+
+function cfg(connector) {
+  return connector.authConfig ? JSON.parse(connector.authConfig) : {};
+}
+
+function client(token) {
+  return axios.create({
+    baseURL: "https://slack.com/api",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+  });
+}
+
+const TOOLS = c => [
+  { action: "post_message",    desc: `Post a message to a Slack channel via ${c.name}.`,
+    params: { channel: { type: "string", description: "Channel name or ID (e.g. #general)" },
+              text:    { type: "string", description: "Message text to post." } }, required: ["channel","text"] },
+  { action: "list_channels",   desc: `List public Slack channels via ${c.name}.`,   params: {}, required: [] },
+  { action: "search_messages", desc: `Search Slack messages via ${c.name}.`,
+    params: { query: { type: "string", description: "Search query." } }, required: ["query"] },
+];
+
+function getToolDefinitions(connector) {
+  return TOOLS(connector).map(t => ({
+    type: "function",
+    function: {
+      name: `conn_${connector.id}_${t.action}`,
+      description: t.desc,
+      parameters: { type: "object", properties: t.params, required: t.required },
+    },
+  }));
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return TOOLS(connector).map(t => ({
+    name: `conn_${connector.id}_${t.action}`,
+    description: t.desc,
+    input_schema: { type: "object", properties: t.params, required: t.required },
+  }));
+}
+
+async function executeTool(action, args, connector) {
+  const { botToken } = cfg(connector);
+  if (!botToken) return "Slack not configured. Please add credentials in Integrations.";
+  const api = client(botToken);
+
+  try {
+    if (action === "post_message") {
+      const { channel, text } = args;
+      const res = await api.post("/chat.postMessage", { channel, text });
+      if (!res.data.ok) return `Slack error: ${res.data.error}`;
+      return `Message posted to ${channel}.`;
+    }
+
+    if (action === "list_channels") {
+      const res = await api.get("/conversations.list?types=public_channel&limit=50");
+      if (!res.data.ok) return `Slack error: ${res.data.error}`;
+      const channels = (res.data.channels || []).map(c => `#${c.name} (${c.num_members} members)`);
+      return channels.length ? channels.join("\n") : "No channels found.";
+    }
+
+    if (action === "search_messages") {
+      const res = await api.get(`/search.messages?query=${encodeURIComponent(args.query)}&count=10`);
+      if (!res.data.ok) return `Slack error: ${res.data.error}`;
+      const matches = res.data.messages?.matches || [];
+      if (!matches.length) return "No messages found.";
+      return matches.map(m => `[${m.channel?.name}] ${m.username}: ${m.text}`).join("\n\n");
+    }
+
+    return `Unknown Slack action: ${action}`;
+  } catch (err) {
+    return `Slack error: ${err.response?.data?.error || err.message}`;
+  }
+}
+
+async function testConnection(authConfig) {
+  try {
+    const res = await client(authConfig.botToken).get("/auth.test");
+    return res.data.ok;
+  } catch { return false; }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool, testConnection };

package/src/utils/tools/adapters/speech.js

@@ -0,0 +1,160 @@
+"use strict";
+const axios = require("axios");
+const path  = require("path");
+const fs    = require("fs");
+const os    = require("os");
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_text_to_speech`,
+        description: `Convert text to speech audio using "${connector.name}". Returns a URL or base64 audio.`,
+        parameters: {
+          type: "object",
+          properties: {
+            text:      { type: "string", description: "Text to convert to speech" },
+            voice:     { type: "string", description: "Voice ID or name to use (provider-specific)" },
+            language:  { type: "string", description: "Language code (e.g. 'en-US', 'fr-FR'). Optional." },
+            speed:     { type: "number", description: "Speaking speed multiplier (0.5 to 2.0, default 1.0)" },
+          },
+          required: ["text"],
+        },
+      },
+    },
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_list_voices`,
+        description: `List available voices from "${connector.name}".`,
+        parameters: { type: "object", properties: {}, required: [] },
+      },
+    },
+  ];
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return getToolDefinitions(connector).map(t => ({
+    name:         t.function.name,
+    description:  t.function.description,
+    input_schema: t.function.parameters,
+  }));
+}
+
+async function executeTool(action, args, connector) {
+  const auth  = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  const cfg   = connector.config     ? JSON.parse(connector.config)     : {};
+  const creds = { ...cfg, ...auth };
+  const type  = connector.type;
+
+  // ── ElevenLabs ────────────────────────────────────────────────────────────
+  if (type === "elevenlabs") {
+    if (action === "list_voices") {
+      const resp = await axios.get("https://api.elevenlabs.io/v1/voices", {
+        headers: { "xi-api-key": creds.apiKey },
+      });
+      const voices = (resp.data.voices || []).map(v => `${v.name} (${v.voice_id})`).join("\n");
+      return `Available voices:\n${voices}`;
+    }
+    if (action === "text_to_speech") {
+      const voiceId = args.voice || creds.voiceId || "EXAVITQu4vr4xnSDxMaL";
+      const resp    = await axios.post(
+        `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`,
+        { text: args.text, model_id: "eleven_monolingual_v1", voice_settings: { stability: 0.5, similarity_boost: 0.75 } },
+        { headers: { "xi-api-key": creds.apiKey, "Content-Type": "application/json" }, responseType: "arraybuffer" }
+      );
+      const tmpFile = path.join(os.tmpdir(), `oe-tts-${Date.now()}.mp3`);
+      fs.writeFileSync(tmpFile, resp.data);
+      return `Audio generated and saved to: ${tmpFile} (${Math.round(resp.data.byteLength / 1024)}KB MP3)`;
+    }
+  }
+
+  // ── OpenAI TTS ────────────────────────────────────────────────────────────
+  if (type === "openai-tts") {
+    if (action === "list_voices") {
+      return "Available voices: alloy, echo, fable, onyx, nova, shimmer";
+    }
+    if (action === "text_to_speech") {
+      const resp = await axios.post(
+        "https://api.openai.com/v1/audio/speech",
+        { model: "tts-1", input: args.text, voice: args.voice || creds.voice || "alloy", speed: args.speed || 1.0 },
+        { headers: { Authorization: `Bearer ${creds.apiKey}`, "Content-Type": "application/json" }, responseType: "arraybuffer" }
+      );
+      const tmpFile = path.join(os.tmpdir(), `oe-tts-${Date.now()}.mp3`);
+      fs.writeFileSync(tmpFile, resp.data);
+      return `Audio generated and saved to: ${tmpFile} (${Math.round(resp.data.byteLength / 1024)}KB MP3)`;
+    }
+  }
+
+  // ── Azure Cognitive Speech ────────────────────────────────────────────────
+  if (type === "azure-speech") {
+    if (action === "list_voices") {
+      const region = creds.region || "eastus";
+      const token  = await axios.post(
+        `https://${region}.api.cognitive.microsoft.com/sts/v1.0/issuetoken`,
+        null,
+        { headers: { "Ocp-Apim-Subscription-Key": creds.subscriptionKey } }
+      );
+      const resp = await axios.get(
+        `https://${region}.tts.speech.microsoft.com/cognitiveservices/voices/list`,
+        { headers: { Authorization: `Bearer ${token.data}` } }
+      );
+      const voices = (resp.data || []).slice(0, 20).map(v => `${v.ShortName} (${v.Locale})`).join("\n");
+      return `Available voices (first 20):\n${voices}`;
+    }
+    if (action === "text_to_speech") {
+      const region = creds.region || "eastus";
+      const voice  = args.voice || "en-US-JennyNeural";
+      const lang   = args.language || "en-US";
+      const ssml   = `<speak version='1.0' xml:lang='${lang}'><voice name='${voice}'>${args.text}</voice></speak>`;
+      const token  = await axios.post(
+        `https://${region}.api.cognitive.microsoft.com/sts/v1.0/issuetoken`,
+        null,
+        { headers: { "Ocp-Apim-Subscription-Key": creds.subscriptionKey } }
+      );
+      const resp = await axios.post(
+        `https://${region}.tts.speech.microsoft.com/cognitiveservices/v1`,
+        ssml,
+        {
+          headers: { Authorization: `Bearer ${token.data}`, "Content-Type": "application/ssml+xml", "X-Microsoft-OutputFormat": "audio-24khz-48kbitrate-mono-mp3" },
+          responseType: "arraybuffer",
+        }
+      );
+      const tmpFile = path.join(os.tmpdir(), `oe-tts-${Date.now()}.mp3`);
+      fs.writeFileSync(tmpFile, resp.data);
+      return `Audio generated and saved to: ${tmpFile} (${Math.round(resp.data.byteLength / 1024)}KB MP3)`;
+    }
+  }
+
+  // ── Google Text-to-Speech ─────────────────────────────────────────────────
+  if (type === "google-tts") {
+    if (action === "list_voices") {
+      const resp = await axios.get(
+        `https://texttospeech.googleapis.com/v1/voices?key=${creds.apiKey}`
+      );
+      const voices = (resp.data.voices || []).slice(0, 20).map(v => `${v.name} (${v.languageCodes?.join(", ")})`).join("\n");
+      return `Available voices (first 20):\n${voices}`;
+    }
+    if (action === "text_to_speech") {
+      const lang  = args.language || "en-US";
+      const voice = args.voice    || "en-US-Standard-A";
+      const resp  = await axios.post(
+        `https://texttospeech.googleapis.com/v1/text:synthesize?key=${creds.apiKey}`,
+        {
+          input:       { text: args.text },
+          voice:       { languageCode: lang, name: voice },
+          audioConfig: { audioEncoding: "MP3", speakingRate: args.speed || 1.0 },
+        }
+      );
+      const audio   = Buffer.from(resp.data.audioContent, "base64");
+      const tmpFile = path.join(os.tmpdir(), `oe-tts-${Date.now()}.mp3`);
+      fs.writeFileSync(tmpFile, audio);
+      return `Audio generated and saved to: ${tmpFile} (${Math.round(audio.byteLength / 1024)}KB MP3)`;
+    }
+  }
+
+  return `Unsupported action "${action}" for speech connector type: ${type}`;
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };

package/src/utils/tools/adapters/ssh.js

@@ -0,0 +1,113 @@
+const { Client } = require("ssh2");
+
+function getConfig(connector) {
+  const auth   = connector.authConfig ? JSON.parse(connector.authConfig) : {};
+  const config = connector.config     ? JSON.parse(connector.config)     : {};
+  return {
+    host:       auth.host        || config.host        || "localhost",
+    port:       parseInt(auth.port || config.port || "22"),
+    username:   auth.username    || config.username    || "root",
+    privateKey: auth.privateKey  || config.privateKey  || null,
+    passphrase: auth.passphrase  || config.passphrase  || undefined,
+    password:   auth.password    || config.password    || undefined,
+  };
+}
+
+function runCommand(cfg, command, timeout = 30000) {
+  return new Promise((resolve, reject) => {
+    const conn = new Client();
+    let output = "";
+    let stderr = "";
+    let settled = false;
+
+    const done = (err) => {
+      if (settled) return;
+      settled = true;
+      conn.end();
+      if (err) reject(err);
+      else resolve({ stdout: output, stderr });
+    };
+
+    const timer = setTimeout(() => done(new Error(`Command timed out after ${timeout / 1000}s`)), timeout);
+
+    conn.on("ready", () => {
+      conn.exec(command, (err, stream) => {
+        if (err) { clearTimeout(timer); return done(err); }
+        stream
+          .on("close", () => { clearTimeout(timer); done(); })
+          .on("data",  d => { output += d.toString(); })
+          .stderr.on("data", d => { stderr += d.toString(); });
+      });
+    });
+
+    conn.on("error", err => { clearTimeout(timer); done(err); });
+
+    const connectCfg = { host: cfg.host, port: cfg.port, username: cfg.username };
+    if (cfg.privateKey) {
+      connectCfg.privateKey = cfg.privateKey;
+      if (cfg.passphrase) connectCfg.passphrase = cfg.passphrase;
+    } else if (cfg.password) {
+      connectCfg.password = cfg.password;
+    }
+    conn.connect(connectCfg);
+  });
+}
+
+function getToolDefinitions(connector) {
+  return [
+    {
+      type: "function",
+      function: {
+        name: `conn_${connector.id}_exec`,
+        description: `Run a shell command on the remote server via SSH (${connector.name}). Use for security audits, log inspection, process checks, port scans, disk usage, and system diagnostics.`,
+        parameters: {
+          type: "object",
+          properties: {
+            command: { type: "string", description: "Shell command to execute on the remote server." },
+            timeout: { type: "number", description: "Timeout in seconds (default 30, max 120)." },
+          },
+          required: ["command"],
+        },
+      },
+    },
+  ];
+}
+
+function getAnthropicToolDefinitions(connector) {
+  return [
+    {
+      name: `conn_${connector.id}_exec`,
+      description: `Run a shell command on the remote server via SSH (${connector.name}). Use for security audits, log inspection, process checks, port scans, disk usage, and system diagnostics.`,
+      input_schema: {
+        type: "object",
+        properties: {
+          command: { type: "string", description: "Shell command to execute on the remote server." },
+          timeout: { type: "number", description: "Timeout in seconds (default 30, max 120)." },
+        },
+        required: ["command"],
+      },
+    },
+  ];
+}
+
+async function executeTool(action, args, connector) {
+  if (action !== "exec") return `Unknown SSH action: ${action}`;
+
+  const cfg = getConfig(connector);
+  if (!cfg.privateKey && !cfg.password) return "SSH connector not configured: provide privateKeyPath or password.";
+
+  const { command, timeout } = args;
+  if (!command) return "Missing required field: command.";
+
+  const timeoutMs = Math.min((parseInt(timeout) || 30), 120) * 1000;
+
+  try {
+    const { stdout, stderr } = await runCommand(cfg, command, timeoutMs);
+    const out = (stdout + (stderr ? `\nSTDERR:\n${stderr}` : "")).trim();
+    return out || "(no output)";
+  } catch (err) {
+    return `SSH error: ${err.message}`;
+  }
+}
+
+module.exports = { getToolDefinitions, getAnthropicToolDefinitions, executeTool };