@openenthrium/oe-runtime-sdk 1.7.5

package/src/routes/agents.js

@@ -0,0 +1,193 @@
+const router = require("express").Router();
+const { authenticate, requireManagerOrAdmin } = require("../middleware/auth");
+const { getLLMConfig } = require("../providers/llm");
+const engine = require("../engine");
+
+router.use(authenticate, requireManagerOrAdmin);
+
+// ── List agents for a workspace ───────────────────────────────────────────────
+router.get("/workspaces/:workspaceId/agents", async (req, res) => {
+  try {
+    const workspaceId = parseInt(req.params.workspaceId);
+    const agents = await req.db.agent.findMany({
+      where: { workspaceId },
+      orderBy: { createdAt: "asc" },
+      include: {
+        runs: {
+          orderBy: { startedAt: "desc" },
+          take: 1,
+          select: { status: true, startedAt: true, completedAt: true },
+        },
+      },
+    });
+    res.json({ agents });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ── Create agent ──────────────────────────────────────────────────────────────
+router.post("/workspaces/:workspaceId/agents", async (req, res) => {
+  try {
+    const workspaceId = parseInt(req.params.workspaceId);
+    const { name, description, systemPrompt, workflow, connectorIds } = req.body;
+    if (!name?.trim()) return res.status(400).json({ error: "Name required" });
+    const agent = await req.db.agent.create({
+      data: {
+        workspaceId,
+        name:           name.trim(),
+        description:    description?.trim() || null,
+        systemPrompt:   systemPrompt?.trim() || null,
+        workflow:       typeof workflow === "string" ? workflow : JSON.stringify(workflow || []),
+        connectorIds:   typeof connectorIds === "string" ? connectorIds : JSON.stringify(connectorIds || []),
+        createdByUserId: req.user.id || null,
+      },
+    });
+    res.json({ agent });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ── Update agent ──────────────────────────────────────────────────────────────
+router.put("/workspaces/:workspaceId/agents/:id", async (req, res) => {
+  try {
+    const id = parseInt(req.params.id);
+    const { name, description, systemPrompt, workflow, connectorIds, enabled } = req.body;
+    const data = {};
+    if (name         !== undefined) data.name         = name.trim();
+    if (description  !== undefined) data.description  = description?.trim() || null;
+    if (systemPrompt !== undefined) data.systemPrompt = systemPrompt?.trim() || null;
+    if (workflow     !== undefined) data.workflow     = typeof workflow === "string" ? workflow : JSON.stringify(workflow || []);
+    if (connectorIds !== undefined) data.connectorIds = typeof connectorIds === "string" ? connectorIds : JSON.stringify(connectorIds || []);
+    if (enabled      !== undefined) data.enabled      = enabled;
+    const agent = await req.db.agent.update({ where: { id }, data });
+    res.json({ agent });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ── Delete agent ──────────────────────────────────────────────────────────────
+router.delete("/workspaces/:workspaceId/agents/:id", async (req, res) => {
+  try {
+    const id = parseInt(req.params.id);
+    await req.db.agent.delete({ where: { id } });
+    res.json({ success: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ── Run history ───────────────────────────────────────────────────────────────
+router.get("/workspaces/:workspaceId/agents/:id/runs", async (req, res) => {
+  try {
+    const agentId = parseInt(req.params.id);
+    const runs = await req.db.agentRun.findMany({
+      where: { agentId },
+      orderBy: { startedAt: "desc" },
+      take: 10,
+    });
+    res.json({ runs });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ── Cancel a run ──────────────────────────────────────────────────────────────
+router.post("/workspaces/:workspaceId/agents/:id/runs/:runId/cancel", async (req, res) => {
+  try {
+    const runId = parseInt(req.params.runId);
+    await req.db.$executeRaw`UPDATE AgentRun SET cancelRequested = 1 WHERE id = ${runId}`;
+    res.json({ success: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ── Run agent (SSE) ───────────────────────────────────────────────────────────
+router.post("/workspaces/:workspaceId/agents/:id/run", async (req, res) => {
+  const agentId     = parseInt(req.params.id);
+  const workspaceId = parseInt(req.params.workspaceId);
+  const { input }   = req.body;
+
+  const [agent, workspace] = await Promise.all([
+    req.db.agent.findUnique({ where: { id: agentId } }),
+    req.db.workspace.findUnique({ where: { id: workspaceId } }),
+  ]);
+  if (!agent)     return res.status(404).json({ error: "Agent not found" });
+  if (!workspace) return res.status(404).json({ error: "Workspace not found" });
+
+  // Build connector list from workspace agentConfig (inline credentials)
+  const agentConfig = (() => { try { return JSON.parse(workspace.agentConfig || "{}"); } catch { return {}; } })();
+  const allConnectors = (agentConfig.connectors || []).map((c, i) => ({
+    id:   i + 1,
+    name: c.connection_name,
+    type: c.connection_type,
+    ...c, // spread all credential fields (bearerToken, baseUrl, host, password, etc.)
+  }));
+
+  // Filter to connectors the agent declared
+  const referencedNames = (() => { try { return JSON.parse(agent.connectorIds || "[]"); } catch { return []; } })();
+  const connectors = referencedNames.length
+    ? allConnectors.filter(c => referencedNames.includes(c.name))
+    : allConnectors; // if agent declares none, give it all
+
+  const run = await req.db.agentRun.create({
+    data: {
+      agentId,
+      triggeredByUserId: req.user.id || null,
+      status:      "running",
+      input:       input || null,
+    },
+  });
+
+  res.setHeader("Content-Type",  "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection",    "keep-alive");
+
+  const { executeTool } = require("../utils/tools/registry");
+
+  try {
+    const llmConfig = await getLLMConfig();
+    const steps     = (() => { try { return JSON.parse(agent.workflow || "[]"); } catch { return []; } })();
+
+    await engine.run(
+      {
+        systemPrompt: agent.systemPrompt,
+        workflow:     steps,
+        params:       [],
+        maxRounds:    25,
+        input,
+      },
+      llmConfig,
+      connectors,
+      {
+        toolExecutor: (name, args, conns) => executeTool(name, args, conns, req.db),
+        onToolCall:   (name) => res.write(`data: ${JSON.stringify({ tool_call: name })}\n\n`),
+        checkCancel:  async () => {
+          const [cr] = await req.db.$queryRaw`SELECT cancelRequested FROM AgentRun WHERE id = ${run.id}`;
+          return cr?.cancelRequested;
+        },
+        onDone: async (output) => {
+          await req.db.agentRun.update({ where: { id: run.id }, data: { status: "success", output, completedAt: new Date() } });
+          res.write(`data: ${JSON.stringify({ done: true, output, runId: run.id })}\n\n`);
+          res.end();
+        },
+        onError: async (err) => {
+          await req.db.agentRun.update({ where: { id: run.id }, data: { status: "error", error: err.message, completedAt: new Date() } });
+          res.write(`data: ${JSON.stringify({ error: err.message })}\n\n`);
+          res.end();
+        },
+      }
+    );
+  } catch (err) {
+    if (!res.writableEnded) {
+      await req.db.agentRun.update({ where: { id: run.id }, data: { status: "error", error: err.message, completedAt: new Date() } }).catch(() => {});
+      res.write(`data: ${JSON.stringify({ error: err.message })}\n\n`);
+      res.end();
+    }
+  }
+});
+
+module.exports = router;

package/src/routes/apiKeys.js

@@ -0,0 +1,55 @@
+const router = require("express").Router();
+const crypto = require("crypto");
+const { authenticate, requireManagerOrAdmin } = require("../middleware/auth");
+const { logActivity } = require("../utils/activityLog");
+
+router.use(authenticate, requireManagerOrAdmin);
+
+// List all API keys (never returns raw key)
+router.get("/", async (req, res) => {
+  const keys = await req.db.apiKey.findMany({
+    orderBy: { createdAt: "desc" },
+    include: { createdBy: { select: { id: true, name: true, email: true } } }
+  });
+  res.json({ keys });
+});
+
+// Create new API key — returns raw key ONCE
+router.post("/", async (req, res) => {
+  const { name } = req.body;
+  if (!name?.trim()) return res.status(400).json({ error: "Name required" });
+
+  const rawKey   = "emb_" + crypto.randomBytes(16).toString("hex");
+  const keyHash  = crypto.createHash("sha256").update(rawKey).digest("hex");
+  const keyPrefix = rawKey.slice(0, 12);
+
+  const apiKey = await req.db.apiKey.create({
+    data: { name: name.trim(), keyHash, keyPrefix, createdById: req.user.id || null },
+    include: { createdBy: { select: { id: true, name: true, email: true } } }
+  });
+
+  await logActivity(req.db, req.user, "apikey.created", { name: name.trim(), prefix: keyPrefix });
+  res.json({ apiKey, rawKey });
+});
+
+// Revoke an API key (soft)
+router.patch("/:id/revoke", async (req, res) => {
+  const apiKey = await req.db.apiKey.findUnique({ where: { id: parseInt(req.params.id) } });
+  if (!apiKey) return res.status(404).json({ error: "API key not found" });
+
+  await req.db.apiKey.update({ where: { id: apiKey.id }, data: { revoked: true } });
+  await logActivity(req.db, req.user, "apikey.revoked", { name: apiKey.name, prefix: apiKey.keyPrefix });
+  res.json({ success: true });
+});
+
+// Delete an API key (hard)
+router.delete("/:id", async (req, res) => {
+  const apiKey = await req.db.apiKey.findUnique({ where: { id: parseInt(req.params.id) } });
+  if (!apiKey) return res.status(404).json({ error: "API key not found" });
+
+  await req.db.apiKey.delete({ where: { id: apiKey.id } });
+  await logActivity(req.db, req.user, "apikey.deleted", { name: apiKey.name, prefix: apiKey.keyPrefix });
+  res.json({ success: true });
+});
+
+module.exports = router;

package/src/routes/audio.js

@@ -0,0 +1,111 @@
+const router  = require("express").Router();
+const multer  = require("multer");
+const { authenticate } = require("../middleware/auth");
+const { getSetting }   = require("../providers/llm");
+
+const upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: 25 * 1024 * 1024 } });
+
+// ── TTS ───────────────────────────────────────────────────────────────────────
+
+router.post("/tts", authenticate, async (req, res) => {
+  const { text } = req.body;
+  if (!text) return res.status(400).json({ error: "text required" });
+
+  const provider = (await getSetting("tts_provider")) || "native";
+  const safeText = text.slice(0, 4096);
+
+  try {
+    if (provider === "elevenlabs") {
+      const apiKey  = await getSetting("tts_elevenlabs_key");
+      const voiceId = (await getSetting("tts_elevenlabs_voice_id")) || "21m00Tcm4TlvDq8ikWAM";
+      if (!apiKey) return res.status(400).json({ error: "ElevenLabs API key not configured" });
+
+      const resp = await fetch(`https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`, {
+        method:  "POST",
+        headers: { "xi-api-key": apiKey, "Content-Type": "application/json", Accept: "audio/mpeg" },
+        body:    JSON.stringify({ text: safeText, model_id: "eleven_monolingual_v1" })
+      });
+      if (!resp.ok) throw new Error(`ElevenLabs error: ${resp.status}`);
+      const buf = Buffer.from(await resp.arrayBuffer());
+      res.setHeader("Content-Type", "audio/mpeg");
+      return res.send(buf);
+    }
+
+    // OpenAI or generic-openai
+    const { default: OpenAI } = await import("openai");
+    let client;
+
+    if (provider === "generic-openai") {
+      const baseURL = await getSetting("tts_generic_base_url");
+      const apiKey  = (await getSetting("tts_generic_api_key")) || "none";
+      if (!baseURL) return res.status(400).json({ error: "Generic TTS base URL not configured" });
+      client = new OpenAI({ apiKey, baseURL });
+    } else {
+      const apiKey = (await getSetting("llm_api_key")) || process.env.OPENAI_API_KEY;
+      if (!apiKey) return res.status(400).json({ error: "OpenAI API key not configured" });
+      client = new OpenAI({ apiKey });
+    }
+
+    const voice = (await getSetting("tts_voice")) || "alloy";
+    const model = (await getSetting("tts_model")) || "tts-1";
+    const gVoice = provider === "generic-openai" ? ((await getSetting("tts_generic_voice")) || "alloy") : voice;
+
+    const mp3 = await client.audio.speech.create({ model, voice: gVoice, input: safeText });
+    const buf = Buffer.from(await mp3.arrayBuffer());
+    res.setHeader("Content-Type", "audio/mpeg");
+    res.setHeader("Content-Length", buf.length);
+    res.send(buf);
+  } catch (err) {
+    console.error("[TTS]", err.message);
+    res.status(500).json({ error: "TTS failed: " + err.message });
+  }
+});
+
+// ── STT ───────────────────────────────────────────────────────────────────────
+
+router.post("/stt", authenticate, upload.single("audio"), async (req, res) => {
+  if (!req.file) return res.status(400).json({ error: "audio file required" });
+
+  const provider = (await getSetting("stt_provider")) || "native";
+
+  try {
+    if (provider === "deepgram") {
+      const apiKey = await getSetting("stt_deepgram_key");
+      if (!apiKey) return res.status(400).json({ error: "Deepgram API key not configured" });
+
+      const resp = await fetch("https://api.deepgram.com/v1/listen?model=nova-2&smart_format=true", {
+        method:  "POST",
+        headers: { "Authorization": `Token ${apiKey}`, "Content-Type": req.file.mimetype || "audio/webm" },
+        body:    req.file.buffer
+      });
+      if (!resp.ok) throw new Error(`Deepgram error: ${resp.status}`);
+      const data = await resp.json();
+      const transcript = data.results?.channels?.[0]?.alternatives?.[0]?.transcript || "";
+      return res.json({ transcript });
+    }
+
+    // OpenAI Whisper or generic-openai
+    const { default: OpenAI } = await import("openai");
+    let client;
+
+    if (provider === "generic-openai") {
+      const baseURL = await getSetting("stt_generic_base_url");
+      const apiKey  = (await getSetting("stt_generic_api_key")) || "none";
+      if (!baseURL) return res.status(400).json({ error: "Generic STT base URL not configured" });
+      client = new OpenAI({ apiKey, baseURL });
+    } else {
+      const apiKey = (await getSetting("llm_api_key")) || process.env.OPENAI_API_KEY;
+      if (!apiKey) return res.status(400).json({ error: "OpenAI API key not configured" });
+      client = new OpenAI({ apiKey });
+    }
+
+    const audioFile = new File([req.file.buffer], "audio.webm", { type: req.file.mimetype || "audio/webm" });
+    const result = await client.audio.transcriptions.create({ file: audioFile, model: "whisper-1" });
+    res.json({ transcript: result.text });
+  } catch (err) {
+    console.error("[STT]", err.message);
+    res.status(500).json({ error: "STT failed: " + err.message });
+  }
+});
+
+module.exports = router;

package/src/routes/auth.js

@@ -0,0 +1,83 @@
+const router = require("express").Router();
+const bcrypt = require("bcryptjs");
+const jwt = require("jsonwebtoken");
+const { authenticate } = require("../middleware/auth");
+
+const SUPER_ADMIN = {
+  email:    process.env.SUPER_ADMIN_EMAIL,
+  password: process.env.SUPER_ADMIN_PASSWORD,
+  name:     process.env.SUPER_ADMIN_NAME || "Super Admin",
+};
+
+router.post("/login", async (req, res) => {
+  const { email, password } = req.body;
+  if (!email || !password) return res.status(400).json({ error: "Email and password required" });
+
+  // Super admin from .env — bypasses DB entirely
+  if (SUPER_ADMIN.email && SUPER_ADMIN.password && email.toLowerCase() === SUPER_ADMIN.email.toLowerCase() && password === SUPER_ADMIN.password) {
+    const token = jwt.sign(
+      { id: 0, email: SUPER_ADMIN.email, role: "admin", name: SUPER_ADMIN.name },
+      process.env.JWT_SECRET,
+      { expiresIn: "7d" }
+    );
+    return res.json({ token, user: { id: 0, email: SUPER_ADMIN.email, name: SUPER_ADMIN.name, role: "admin" } });
+  }
+
+  const user = await req.db.user.findUnique({ where: { email: email.toLowerCase() } });
+  if (!user || user.suspended) return res.status(401).json({ error: "Invalid credentials" });
+
+  const valid = await bcrypt.compare(password, user.password);
+  if (!valid) return res.status(401).json({ error: "Invalid credentials" });
+
+  const token = jwt.sign(
+    { id: user.id, email: user.email, role: user.role, name: user.name },
+    process.env.JWT_SECRET,
+    { expiresIn: "7d" }
+  );
+
+  res.json({ token, user: { id: user.id, email: user.email, name: user.name, role: user.role } });
+});
+
+router.get("/me", authenticate, async (req, res) => {
+  if (req.user.id === 0) {
+    return res.json({ user: { id: 0, email: SUPER_ADMIN.email, name: SUPER_ADMIN.name, role: "admin" } });
+  }
+  const user = await req.db.user.findUnique({
+    where: { id: req.user.id },
+    select: { id: true, email: true, name: true, role: true }
+  });
+  res.json({ user });
+});
+
+router.put("/me", authenticate, async (req, res) => {
+  const { name, currentPassword, newPassword } = req.body;
+
+  // Super admin — only allow name update (password lives in .env)
+  if (req.user.id === 0) {
+    return res.status(400).json({ error: "Super admin credentials are managed via .env" });
+  }
+
+  const user = await req.db.user.findUnique({ where: { id: req.user.id } });
+  if (!user) return res.status(404).json({ error: "User not found" });
+
+  const updates = {};
+  if (name !== undefined) updates.name = name.trim();
+
+  if (newPassword) {
+    if (!currentPassword) return res.status(400).json({ error: "Current password required" });
+    const valid = await bcrypt.compare(currentPassword, user.password);
+    if (!valid) return res.status(400).json({ error: "Current password is incorrect" });
+    if (newPassword.length < 6) return res.status(400).json({ error: "New password must be at least 6 characters" });
+    updates.password = await bcrypt.hash(newPassword, 10);
+  }
+
+  const updated = await req.db.user.update({
+    where: { id: req.user.id },
+    data: updates,
+    select: { id: true, email: true, name: true, role: true }
+  });
+
+  res.json({ user: updated });
+});
+
+module.exports = router;