server.js

import express from "express";
import dotenv from "dotenv";
import path from "path";
import { fileURLToPath } from "url";

dotenv.config();

const app = express();
const port = process.env.PORT || 8787;
const trioBase = process.env.TRIO_BASE_URL || "https://trio.machinefi.com/api";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

app.use(express.json({ limit: "1mb" }));
app.use(express.static(path.join(__dirname, "public")));

function getApiKey(req) {
  return req.get("x-trio-api-key") || process.env.TRIO_API_KEY || "";
}

async function trioRequest(req, res, config) {
  try {
    const apiKey = getApiKey(req);
    if (!apiKey) {
      return res.status(400).json({
        error: {
          code: "MISSING_API_KEY",
          message: "Provide Trio API key in x-trio-api-key header or TRIO_API_KEY env."
        }
      });
    }

    const headers = {
      Authorization: `Bearer ${apiKey}`,
      ...(config.headers || {})
    };

    const trioRes = await fetch(config.url, {
      method: config.method || "GET",
      headers,
      body: config.body
    });

    if (config.stream) {
      if (!trioRes.ok) {
        const errText = await trioRes.text();
        res.status(trioRes.status).json(parsePossibleJson(errText));
        return;
      }

      res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
      res.setHeader("Cache-Control", "no-cache, no-transform");
      res.setHeader("Connection", "keep-alive");

      if (res.flushHeaders) {
        res.flushHeaders();
      }

      const reader = trioRes.body?.getReader();
      if (!reader) {
        res.status(500).write("event: error\ndata: {\"message\":\"No stream body\"}\n\n");
        res.end();
        return;
      }

      while (true) {
        const { done, value } = await reader.read();
        if (done) break;
        res.write(Buffer.from(value));
      }

      res.end();
      return;
    }

    const rawText = await trioRes.text();
    const data = parsePossibleJson(rawText);
    res.status(trioRes.status).json(data);
  } catch (error) {
    res.status(500).json({
      error: {
        code: "PROXY_ERROR",
        message: error instanceof Error ? error.message : "Unknown proxy error"
      }
    });
  }
}

function parsePossibleJson(rawText) {
  if (!rawText) return {};
  try {
    return JSON.parse(rawText);
  } catch {
    return { message: rawText };
  }
}

app.post("/api/streams/validate", (req, res) => {
  const body = JSON.stringify({ stream_url: req.body.stream_url || "" });
  return trioRequest(req, res, {
    url: `${trioBase}/streams/validate`,
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body
  });
});

app.post("/api/prepare-stream", (req, res) => {
  const url = new URL(`${trioBase}/prepare-stream`);
  url.searchParams.set("url", req.body.stream_url || "");

  return trioRequest(req, res, {
    url: url.toString(),
    method: "POST"
  });
});

app.post("/api/check-once", (req, res) => {
  const body = JSON.stringify({
    stream_url: req.body.stream_url || "",
    condition: req.body.condition || ""
  });

  return trioRequest(req, res, {
    url: `${trioBase}/check-once`,
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body
  });
});

app.post("/api/live-monitor", (req, res) => {
  const body = JSON.stringify({
    stream_url: req.body.stream_url || "",
    condition: req.body.condition || "",
    webhook_url: req.body.webhook_url || ""
  });

  return trioRequest(req, res, {
    url: `${trioBase}/live-monitor`,
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body
  });
});

app.post("/api/live-digest/stream", (req, res) => {
  const body = JSON.stringify({
    stream_url: req.body.stream_url || ""
  });

  return trioRequest(req, res, {
    url: `${trioBase}/live-digest`,
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Accept: "text/event-stream"
    },
    body,
    stream: true
  });
});

app.get("/api/jobs", (req, res) => {
  const url = new URL(`${trioBase}/jobs`);
  ["status", "job_type", "limit", "offset"].forEach((key) => {
    if (req.query[key]) url.searchParams.set(key, String(req.query[key]));
  });

  return trioRequest(req, res, {
    url: url.toString()
  });
});

app.get("/api/jobs/:jobId", (req, res) => {
  return trioRequest(req, res, {
    url: `${trioBase}/jobs/${encodeURIComponent(req.params.jobId)}`
  });
});

app.delete("/api/jobs/:jobId", (req, res) => {
  return trioRequest(req, res, {
    url: `${trioBase}/jobs/${encodeURIComponent(req.params.jobId)}`,
    method: "DELETE"
  });
});

app.get("/api/meta", (req, res) => {
  res.json({
    trio_base_url: trioBase,
    has_env_key: Boolean(process.env.TRIO_API_KEY)
  });
});

app.listen(port, () => {
  console.log(`Trio demo app running at http://localhost:${port}`);
});