@henriquecosta/chaos-api 1.0.0

package/dist/dashboard/server/control-api.js

@@ -0,0 +1,140 @@
+import { createServer } from "node:http";
+import { applyPreset, findPreset, listPresets } from "../../presets/index.js";
+const CORS_HEADERS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET,POST,PATCH,DELETE,OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type",
+};
+/**
+ * Local control API for the scenario StateStore living inside the user's app process.
+ * dashboard-ui talks to this directly (CORS-open, localhost-only by convention) — the
+ * dashboard-server process only serves static UI files, it does not proxy this API.
+ */
+export function createControlApi(store, activityLog) {
+    return createServer((req, res) => {
+        void handleRequest(req, res, store, activityLog);
+    });
+}
+async function handleRequest(req, res, store, activityLog) {
+    for (const [key, value] of Object.entries(CORS_HEADERS))
+        res.setHeader(key, value);
+    if (req.method === "OPTIONS") {
+        res.writeHead(204).end();
+        return;
+    }
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const segments = url.pathname.split("/").filter(Boolean);
+    try {
+        if (segments[0] !== "api") {
+            notFound(res);
+            return;
+        }
+        if (segments[1] === "activity" && segments.length === 2 && req.method === "GET") {
+            const limitParam = url.searchParams.get("limit");
+            sendJson(res, 200, activityLog?.list(limitParam ? Number(limitParam) : undefined) ?? []);
+            return;
+        }
+        if (segments[1] === "presets") {
+            if (segments.length === 2 && req.method === "GET") {
+                const category = url.searchParams.get("category");
+                sendJson(res, 200, listPresets((category ?? undefined)));
+                return;
+            }
+            if (segments.length === 4 && segments[3] === "apply" && req.method === "POST") {
+                const name = segments[2];
+                if (!findPreset(name)) {
+                    notFound(res);
+                    return;
+                }
+                const body = await readJsonBody(req);
+                sendJson(res, 201, applyPreset(store, name, body));
+                return;
+            }
+            notFound(res);
+            return;
+        }
+        if (segments[1] === "config") {
+            if (segments.length === 2 && req.method === "GET") {
+                sendJson(res, 200, { scenarios: store.list() });
+                return;
+            }
+            if (segments.length === 2 && req.method === "POST") {
+                const body = await readJsonBody(req);
+                if (!Array.isArray(body.scenarios)) {
+                    throw new Error('body must be { "scenarios": [...] }');
+                }
+                store.clear();
+                for (const scenario of body.scenarios)
+                    store.register(scenario);
+                sendJson(res, 200, { scenarios: store.list() });
+                return;
+            }
+            notFound(res);
+            return;
+        }
+        if (segments[1] !== "scenarios") {
+            notFound(res);
+            return;
+        }
+        if (segments.length === 2 && req.method === "GET") {
+            sendJson(res, 200, store.list());
+            return;
+        }
+        if (segments.length === 2 && req.method === "POST") {
+            const body = await readJsonBody(req);
+            sendJson(res, 201, store.register(body));
+            return;
+        }
+        if (segments.length === 3 && req.method === "PATCH") {
+            const body = await readJsonBody(req);
+            const updated = store.update(segments[2], body);
+            if (!updated) {
+                notFound(res);
+                return;
+            }
+            sendJson(res, 200, updated);
+            return;
+        }
+        if (segments.length === 3 && req.method === "DELETE") {
+            const removed = store.remove(segments[2]);
+            if (!removed) {
+                notFound(res);
+                return;
+            }
+            res.writeHead(204).end();
+            return;
+        }
+        notFound(res);
+    }
+    catch (error) {
+        sendJson(res, 400, { error: error.message });
+    }
+}
+function sendJson(res, status, payload) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(payload));
+}
+function notFound(res) {
+    sendJson(res, 404, { error: "not found" });
+}
+function readJsonBody(req) {
+    return new Promise((resolve, reject) => {
+        let raw = "";
+        req.on("data", (chunk) => {
+            raw += chunk;
+        });
+        req.on("end", () => {
+            if (!raw) {
+                resolve({});
+                return;
+            }
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch {
+                reject(new Error("invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}

package/dist/dashboard/server/index.d.ts

@@ -0,0 +1,10 @@
+import { type Server } from "node:http";
+export interface StartDashboardOptions {
+    port?: number;
+}
+/**
+ * Serves the static dashboard-ui. This process does not hold any scenario state —
+ * dashboard-ui talks directly to the control API running inside the target app
+ * (see src/dashboard/server/control-api.ts and docs/architecture-and-walkthrough.md).
+ */
+export declare function startDashboard(options?: StartDashboardOptions): Server;

package/dist/dashboard/server/index.js

@@ -0,0 +1,49 @@
+import { createServer } from "node:http";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const UI_DIR = path.join(__dirname, "..", "ui");
+const MIME = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "text/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+};
+/**
+ * Serves the static dashboard-ui. This process does not hold any scenario state —
+ * dashboard-ui talks directly to the control API running inside the target app
+ * (see src/dashboard/server/control-api.ts and docs/architecture-and-walkthrough.md).
+ */
+export function startDashboard(options = {}) {
+    const port = options.port ?? 4000;
+    const server = createServer((req, res) => {
+        void serveStatic(req.url ?? "/", res);
+    });
+    server.listen(port, () => {
+        console.log(`[chaos-api] dashboard running at http://localhost:${port}/dashboard`);
+    });
+    return server;
+}
+async function serveStatic(url, res) {
+    let pathname = url.split("?")[0];
+    if (pathname === "/" || pathname === "/dashboard" || pathname === "/dashboard/") {
+        pathname = "/index.html";
+    }
+    else if (pathname.startsWith("/dashboard/")) {
+        pathname = pathname.slice("/dashboard".length);
+    }
+    const filePath = path.join(UI_DIR, pathname);
+    if (!filePath.startsWith(UI_DIR)) {
+        res.writeHead(403).end();
+        return;
+    }
+    try {
+        const content = await readFile(filePath);
+        const ext = path.extname(filePath);
+        res.writeHead(200, { "Content-Type": MIME[ext] ?? "application/octet-stream" });
+        res.end(content);
+    }
+    catch {
+        res.writeHead(404).end("Not found");
+    }
+}

package/dist/dashboard/ui/app.js

@@ -0,0 +1,336 @@
+const STORAGE_KEY = "chaos-api:control-url";
+
+const controlUrlInput = document.getElementById("control-url");
+const connectButton = document.getElementById("connect");
+const listEl = document.getElementById("scenario-list");
+const bannerEl = document.getElementById("status-banner");
+const errorEl = document.getElementById("error");
+const addForm = document.getElementById("add-form");
+const activityListEl = document.getElementById("activity-list");
+const presetCategoriesEl = document.getElementById("preset-categories");
+const presetListEl = document.getElementById("preset-list");
+const exportButton = document.getElementById("export-config");
+const importButton = document.getElementById("import-config");
+const importFileInput = document.getElementById("import-file");
+const runnerForm = document.getElementById("runner-form");
+const runnerResponseEl = document.getElementById("runner-response");
+
+const PRESET_CATEGORIES = [
+  { value: "", label: "todas" },
+  { value: "seguranca", label: "segurança" },
+  { value: "dependencias-externas", label: "deps. externas" },
+  { value: "configuracao", label: "configuração" },
+  { value: "resource-exhaustion", label: "resource exhaustion" },
+  { value: "filesystem", label: "filesystem" },
+];
+let activePresetCategory = "";
+
+controlUrlInput.value = localStorage.getItem(STORAGE_KEY) || controlUrlInput.value;
+
+function controlUrl() {
+  return controlUrlInput.value.replace(/\/$/, "");
+}
+
+async function api(path, options) {
+  const res = await fetch(`${controlUrl()}${path}`, {
+    headers: { "Content-Type": "application/json" },
+    ...options,
+  });
+  if (!res.ok && res.status !== 204) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error(body.error || `request failed: ${res.status}`);
+  }
+  return res.status === 204 ? undefined : res.json();
+}
+
+function scopeLabel(scenario) {
+  return scenario.scope === "global" ? "global" : scenario.scope.pattern;
+}
+
+function renderScenarios(scenarios) {
+  listEl.innerHTML = "";
+  const activeOnes = scenarios.filter((s) => s.enabled);
+
+  bannerEl.style.display = activeOnes.length ? "block" : "none";
+  bannerEl.textContent = activeOnes.length
+    ? `${activeOnes.length} cenário(s) ativo(s): ${activeOnes.map((s) => `${s.type} (${scopeLabel(s)})`).join(", ")}`
+    : "";
+
+  if (!scenarios.length) {
+    listEl.innerHTML = '<p style="color: var(--text-muted)">Nenhum cenário registrado ainda.</p>';
+    return;
+  }
+
+  for (const scenario of scenarios) {
+    const card = document.createElement("div");
+    card.className = `card ${scenario.enabled ? "on" : ""}`;
+    card.innerHTML = `
+      <input type="checkbox" ${scenario.enabled ? "checked" : ""} data-id="${scenario.id}" class="toggle" />
+      <div class="meta">
+        <div class="type">${scenario.type}</div>
+        <div class="scope">${scopeLabel(scenario)} · rate ${scenario.rate}</div>
+      </div>
+      <button class="danger" data-id="${scenario.id}" data-action="remove">Remover</button>
+    `;
+    listEl.appendChild(card);
+  }
+
+  listEl.querySelectorAll(".toggle").forEach((el) => {
+    el.addEventListener("change", async (e) => {
+      const id = e.target.getAttribute("data-id");
+      await withErrorHandling(() => api(`/api/scenarios/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify({ enabled: e.target.checked }),
+      }));
+      await refresh();
+    });
+  });
+
+  listEl.querySelectorAll('[data-action="remove"]').forEach((el) => {
+    el.addEventListener("click", async (e) => {
+      const id = e.target.getAttribute("data-id");
+      await withErrorHandling(() => api(`/api/scenarios/${id}`, { method: "DELETE" }));
+      await refresh();
+    });
+  });
+}
+
+async function withErrorHandling(fn) {
+  errorEl.textContent = "";
+  try {
+    return await fn();
+  } catch (err) {
+    errorEl.textContent = err.message;
+    throw err;
+  }
+}
+
+async function refresh() {
+  const scenarios = await withErrorHandling(() => api("/api/scenarios"));
+  if (scenarios) renderScenarios(scenarios);
+}
+
+function formatTime(timestamp) {
+  return new Date(timestamp).toLocaleTimeString("pt-BR");
+}
+
+function renderActivity(events) {
+  if (!events.length) {
+    activityListEl.innerHTML = '<p style="color: var(--text-muted); padding: 12px">Nenhum cenário disparado ainda.</p>';
+    return;
+  }
+
+  activityListEl.innerHTML = events
+    .map(
+      (event) => `
+        <div class="activity-row">
+          <span class="activity-time">${formatTime(event.timestamp)}</span>
+          <span class="activity-type">${event.scenarioType}</span>
+          <span class="activity-dir">${event.direction}</span>
+          <span class="activity-path">${event.method} ${event.path}</span>
+        </div>
+      `,
+    )
+    .join("");
+}
+
+async function refreshActivity() {
+  const events = await withErrorHandling(() => api("/api/activity?limit=50"));
+  if (events) renderActivity(events);
+}
+
+function renderPresetCategories() {
+  presetCategoriesEl.innerHTML = "";
+  for (const category of PRESET_CATEGORIES) {
+    const button = document.createElement("button");
+    button.textContent = category.label;
+    button.className = category.value === activePresetCategory ? "active" : "";
+    button.addEventListener("click", () => {
+      activePresetCategory = category.value;
+      refreshPresets();
+    });
+    presetCategoriesEl.appendChild(button);
+  }
+}
+
+function renderPresets(presets) {
+  if (!presets.length) {
+    presetListEl.innerHTML = '<p style="color: var(--text-muted)">Nenhum preset nessa categoria.</p>';
+    return;
+  }
+
+  presetListEl.innerHTML = "";
+  for (const preset of presets) {
+    const card = document.createElement("div");
+    card.className = "preset-card";
+    card.innerHTML = `
+      <div class="meta">
+        <div class="name">${preset.name}</div>
+        <div class="description">${preset.description}</div>
+      </div>
+      <button data-name="${preset.name}" data-action="apply-preset">Aplicar</button>
+    `;
+    presetListEl.appendChild(card);
+  }
+
+  presetListEl.querySelectorAll('[data-action="apply-preset"]').forEach((el) => {
+    el.addEventListener("click", async (e) => {
+      const name = e.target.getAttribute("data-name");
+      await withErrorHandling(() => api(`/api/presets/${name}/apply`, {
+        method: "POST",
+        body: JSON.stringify({}),
+      }));
+      await refresh();
+    });
+  });
+}
+
+async function refreshPresets() {
+  renderPresetCategories();
+  const query = activePresetCategory ? `?category=${activePresetCategory}` : "";
+  const presets = await withErrorHandling(() => api(`/api/presets${query}`));
+  if (presets) renderPresets(presets);
+}
+
+connectButton.addEventListener("click", () => {
+  localStorage.setItem(STORAGE_KEY, controlUrlInput.value);
+  refresh();
+  refreshActivity();
+  refreshPresets();
+});
+
+exportButton.addEventListener("click", async () => {
+  const config = await withErrorHandling(() => api("/api/config"));
+  if (!config) return;
+
+  const blob = new Blob([JSON.stringify(config, null, 2)], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = "chaos-api-config.json";
+  link.click();
+  URL.revokeObjectURL(url);
+});
+
+importButton.addEventListener("click", () => importFileInput.click());
+
+importFileInput.addEventListener("change", async () => {
+  const file = importFileInput.files[0];
+  if (!file) return;
+
+  try {
+    const config = JSON.parse(await file.text());
+    await withErrorHandling(() => api("/api/config", { method: "POST", body: JSON.stringify(config) }));
+    await refresh();
+  } catch (err) {
+    errorEl.textContent = err.message;
+  } finally {
+    importFileInput.value = "";
+  }
+});
+
+runnerForm.addEventListener("submit", async (e) => {
+  e.preventDefault();
+  const formData = new FormData(runnerForm);
+  const method = formData.get("method")?.toString() || "GET";
+  const url = formData.get("url")?.toString().trim();
+  const headersRaw = formData.get("headers")?.toString().trim();
+  const bodyRaw = formData.get("body")?.toString().trim();
+
+  runnerResponseEl.innerHTML = "";
+  if (!url) return;
+
+  let headers = {};
+  if (headersRaw) {
+    try {
+      headers = JSON.parse(headersRaw);
+    } catch {
+      runnerResponseEl.innerHTML = '<div class="status error">headers: JSON inválido</div>';
+      return;
+    }
+  }
+
+  const hasBody = bodyRaw && !["GET", "HEAD", "DELETE"].includes(method);
+
+  try {
+    const started = performance.now();
+    const res = await fetch(url, { method, headers, body: hasBody ? bodyRaw : undefined });
+    const elapsedMs = Math.round(performance.now() - started);
+    const text = await res.text();
+    let pretty = text;
+    try {
+      pretty = JSON.stringify(JSON.parse(text), null, 2);
+    } catch {
+      // not JSON — show as-is
+    }
+
+    const responseHeaders = [...res.headers.entries()].map(([k, v]) => `${k}: ${v}`).join("\n");
+    runnerResponseEl.innerHTML = "";
+    runnerResponseEl.appendChild(
+      buildRunnerResult(res.ok, `${res.status} ${res.statusText} · ${elapsedMs}ms`, responseHeaders, pretty),
+    );
+  } catch (err) {
+    runnerResponseEl.innerHTML = "";
+    runnerResponseEl.appendChild(buildRunnerResult(false, err.message, "", ""));
+  }
+});
+
+function buildRunnerResult(ok, statusLine, headersText, bodyText) {
+  const wrapper = document.createElement("div");
+
+  const status = document.createElement("div");
+  status.className = `status ${ok ? "ok" : "error"}`;
+  status.textContent = statusLine;
+  wrapper.appendChild(status);
+
+  if (headersText) {
+    const headers = document.createElement("div");
+    headers.textContent = headersText;
+    wrapper.appendChild(headers);
+  }
+
+  if (bodyText) {
+    const body = document.createElement("div");
+    body.style.marginTop = "8px";
+    body.textContent = bodyText;
+    wrapper.appendChild(body);
+  }
+
+  return wrapper;
+}
+
+setInterval(refreshActivity, 3000);
+
+addForm.addEventListener("submit", async (e) => {
+  e.preventDefault();
+  const formData = new FormData(addForm);
+  const pattern = formData.get("pattern")?.toString().trim();
+  const optionsRaw = formData.get("options")?.toString().trim();
+
+  let options = {};
+  if (optionsRaw) {
+    try {
+      options = JSON.parse(optionsRaw);
+    } catch {
+      errorEl.textContent = "options: JSON inválido";
+      return;
+    }
+  }
+
+  await withErrorHandling(() => api("/api/scenarios", {
+    method: "POST",
+    body: JSON.stringify({
+      type: formData.get("type"),
+      rate: Number(formData.get("rate")),
+      scope: pattern ? { pattern } : "global",
+      options,
+    }),
+  }));
+
+  addForm.reset();
+  await refresh();
+});
+
+refresh();
+refreshActivity();
+refreshPresets();