@gaabrielmooraes/sheet-relay 0.0.0-stage → 0.1.0

package/apps/legends/index.html

@@ -0,0 +1,35 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta httpEquiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no" />
+    <title>Ficha Avatar</title>
+    <!-- The `react-native-web` recommended style reset: https://necolas.github.io/react-native-web/docs/setup/#root-element -->
+    <style id="expo-reset">
+      /* These styles make the body full-height */
+      html,
+      body {
+        height: 100%;
+      }
+      /* These styles disable body scrolling if you are using <ScrollView> */
+      body {
+        overflow: hidden;
+      }
+      /* These styles make the root element full-height */
+      #root {
+        display: flex;
+        height: 100%;
+        flex: 1;
+      }
+    </style>
+  <link rel="icon" href="/ficha/favicon.ico"/></head>
+
+  <body>
+    <!-- Use static rendering with Expo Router to support running without JavaScript. -->
+    <noscript> You need to enable JavaScript to run this app. </noscript>
+    <!-- The root element for your Expo app. -->
+    <div id="root"></div>
+  <script src="/ficha/_expo/static/js/web/index-429d3095530ce378a9ca9b24d24ebda8.js" defer></script>
+</body>
+</html>

package/apps/legends/manifest.json

@@ -0,0 +1,15 @@
+{
+  "name": "Ficha Foundry — Avatar Legends",
+  "short_name": "Ficha Avatar",
+  "description": "Fichas de Avatar Legends do Foundry VTT no celular.",
+  "start_url": "/ficha/",
+  "scope": "/ficha/",
+  "display": "standalone",
+  "background_color": "#1d2433",
+  "theme_color": "#1d2433",
+  "icons": [
+    { "src": "/ficha/icon-192.png", "sizes": "192x192", "type": "image/png" },
+    { "src": "/ficha/icon-512.png", "sizes": "512x512", "type": "image/png" },
+    { "src": "/ficha/icon-maskable-512.png", "sizes": "512x512", "type": "image/png", "purpose": "maskable" }
+  ]
+}

package/apps/legends/metadata.json

@@ -0,0 +1 @@
+{"version":0,"bundler":"metro","fileMetadata":{}}

package/apps/legends/sw.js

@@ -0,0 +1,4 @@
+// Service worker mínimo: só para o navegador oferecer "Instalar app". Sem cache: a ficha precisa estar online (dados ao vivo do Foundry).
+self.addEventListener("install", () => self.skipWaiting());
+self.addEventListener("activate", (e) => e.waitUntil(self.clients.claim()));
+self.addEventListener("fetch", () => {});

package/bin/sheet-relay.mjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+// CLI do pacote npm: `sheet-relay serve` (relay + app) e `sheet-relay headless` (usuário do relay sem Docker).
+import { existsSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const pkg = path.resolve(here, "..");
+const [cmd, ...args] = process.argv.slice(2);
+const opt = (name, def) => { const i = args.indexOf(`--${name}`); return i >= 0 ? args[i + 1] : def; };
+const apps = path.join(pkg, "apps");
+
+const help = () => {
+  console.log(`sheet-relay <command>
+
+  serve     Run the relay and serve the web app.
+              --system <id>   dnd5e | fallout | legends        (env SYSTEM, default dnd5e)
+              --port <n>      (env PORT, default 8787)         --host <h>  (env HOST, default 127.0.0.1)
+              --base <path>   where the app is served (env BASE_PATH, default /ficha; must match the build)
+            Env: RELAY_SECRET (shared secret with the module setting "Relay secret"), TRUST_PROXY=1 behind a reverse proxy.
+  headless  Keep the relay user logged in to your Foundry world (needs: npm i playwright && npx playwright install chromium).
+            Env: FOUNDRY_URL, FOUNDRY_USER, FOUNDRY_PASSWORD, [FOUNDRY_HOST]`);
+};
+
+if (cmd === "serve") {
+  const system = opt("system", process.env.SYSTEM ?? "dnd5e");
+  const dir = path.join(apps, system);
+  if (!existsSync(dir)) { console.error(`No bundled app for "${system}". Available: ${existsSync(apps) ? readdirSync(apps).join(", ") : "none"}`); process.exit(1); }
+  process.env.STATIC_DIR = dir;
+  process.env.BASE_PATH = opt("base", process.env.BASE_PATH ?? "/ficha");
+  const { server } = await import("../server.js");
+  const port = Number(opt("port", process.env.PORT ?? 8787)), host = opt("host", process.env.HOST ?? "127.0.0.1");
+  if (!process.env.RELAY_SECRET) console.warn("WARNING: RELAY_SECRET is not set; anyone who can reach this port can impersonate Foundry.");
+  server.listen(port, host, () => console.log(`sheet-relay on http://${host}:${port}${process.env.BASE_PATH}/ (system ${system})`));
+} else if (cmd === "headless") {
+  await import("../headless.mjs");
+} else { help(); process.exit(cmd ? 1 : 0); }

package/headless.mjs

@@ -0,0 +1,70 @@
+// Mantém o usuário do relay logado no Foundry (sem canvas). Se algo falhar, sai com erro e o Docker reinicia.
+import { chromium } from "playwright";
+
+const { FOUNDRY_URL, FOUNDRY_USER, FOUNDRY_PASSWORD } = process.env;
+if (!FOUNDRY_URL || !FOUNDRY_USER || !FOUNDRY_PASSWORD) throw new Error("defina FOUNDRY_URL, FOUNDRY_USER e FOUNDRY_PASSWORD");
+
+// deste mundo está desligado, espera aqui sem abrir o navegador; quando ele volta, entra.
+const probe = (process.env.FOUNDRY_HOST ? FOUNDRY_URL.replace("localhost", process.env.FOUNDRY_HOST) : FOUNDRY_URL) + "/join";
+for (let warned = false; ; warned = true) {
+  const up = await fetch(probe, { signal: AbortSignal.timeout(5_000) }).then((r) => r.ok, () => false);
+  if (up) break;
+  if (!warned) console.log("Foundry fora do ar; aguardando ele ligar...");
+  await new Promise((r) => setTimeout(r, 15_000));
+}
+
+const browser = await chromium.launch({
+  // O módulo usa crypto.subtle (só em contexto seguro) e abre ws:// no relay (bloqueado em páginas https).
+  // Solução: abrir o Foundry como http://localhost, que é seguro, e resolver "localhost" para o contêiner do Foundry.
+  args: ["--no-sandbox", "--disable-gpu", ...(process.env.FOUNDRY_HOST ? [`--host-resolver-rules=MAP localhost ${process.env.FOUNDRY_HOST}`] : [])]
+});
+browser.on("disconnected", () => process.exit(1));
+const page = await browser.newPage();
+// Foundry ativa módulos por mundo, não por usuário; aqui o navegador do relay recebe um módulo vazio no lugar dos que não estão na lista.
+// audit-logger fica: ele registra no Discord as edições feitas por este cliente (as do app).
+const ALLOW = (process.env.MODULES_ALLOW ?? "sheet-relay,lib-wrapper,audit-logger").split(",");
+// O relay só precisa dos dados: vídeo/YouTube (foundry-tube), imagens e fontes eram ~125% de CPU.
+await page.route("**/*", (r) => {
+  const q = r.request(), url = q.url();
+  if (["image", "media", "font"].includes(q.resourceType()) || /youtube|googlevideo|ytimg|ggpht/.test(url)) return r.abort();
+  const mod = url.match(/\/modules\/([^/]+)\/.*\.(m?js|css)(\?|$)/);
+  if (mod && !ALLOW.includes(mod[1])) return r.fulfill({ contentType: mod[2] === "css" ? "text/css" : "text/javascript", body: mod[2] === "css" ? "" : "export {};" });
+  return r.continue();
+});
+// Configuração de cliente "Sem canvas" do Foundry (o parâmetro ?nocanvas não funciona na v13): evita o WebGL e a CPU alta.
+await page.addInitScript(() => {
+  localStorage.setItem("core.noCanvas", "true");
+  localStorage.setItem("core.performanceMode", "0"); // LOW
+  localStorage.setItem("core.maxFPS", "10");
+});
+await page.goto(`${FOUNDRY_URL}/join`);
+await page.selectOption('select[name="userid"]', { label: FOUNDRY_USER });
+await page.fill('input[name="password"]', FOUNDRY_PASSWORD);
+await page.click('button[name="join"]');
+await page.waitForURL("**/game", { timeout: 30_000 });
+await page.goto(`${FOUNDRY_URL}/game`);
+await page.waitForFunction(() => globalThis.game?.ready, null, { timeout: 120_000 });
+const info = await page.evaluate(() => ({ canvasReady: !!globalThis.canvas?.ready, hasStage: !!globalThis.canvas?.stage, webgl: !!globalThis.canvas?.app?.renderer }));
+console.log(`logado como ${FOUNDRY_USER}`, JSON.stringify(info));
+
+if (process.env.DIAG) { // DIAG=1: perfila o JS da página e imprime as funções mais pesadas (tempo próprio)
+  await new Promise((r) => setTimeout(r, 20_000));
+  const cdp = await page.context().newCDPSession(page);
+  await cdp.send("Profiler.enable"); await cdp.send("Profiler.start");
+  await new Promise((r) => setTimeout(r, 8_000));
+  const { profile } = await cdp.send("Profiler.stop");
+  const self = new Map(); const byId = new Map(profile.nodes.map((n) => [n.id, n]));
+  profile.samples.forEach((id, i) => {
+    const f = byId.get(id).callFrame; const k = `${f.functionName || "(anon)"} ${f.url.replace(/^https?:\/\/[^/]+/, "")}:${f.lineNumber}`;
+    self.set(k, (self.get(k) ?? 0) + (profile.timeDeltas[i] ?? 0));
+  });
+  const total = [...self.values()].reduce((a, b) => a + b, 0);
+  [...self].sort((a, b) => b[1] - a[1]).slice(0, 12).forEach(([k, v]) => console.log(`${((v / total) * 100).toFixed(1)}%  ${k}`));
+  process.exit(0);
+}
+
+for (;;) { // vigia: mundo recarregado, Foundry desligado (socket caiu) ou aba morta -> reinicia o contêiner, que volta a esperar
+  await new Promise((r) => setTimeout(r, 30_000));
+  const ok = await page.evaluate(() => !!globalThis.game?.ready && !!globalThis.game.socket?.connected).catch(() => false);
+  if (!ok) { console.error("sessão perdida"); process.exit(1); }
+}

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@gaabrielmooraes/sheet-relay",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "start": "node server.js",
+    "test": "node test.js && node test-static.js"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "description": "Relay + web app that serve Foundry VTT character sheets to a companion app (players and GM). Pairs with the sheet-relay Foundry module.",
+  "license": "MIT",
+  "bin": {
+    "sheet-relay": "bin/sheet-relay.mjs"
+  },
+  "files": [
+    "server.js",
+    "static.js",
+    "headless.mjs",
+    "bin",
+    "apps",
+    "LICENSE",
+    "NOTICE",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GabrielDiasMoraes/sheet-relay.git"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "foundry-vtt",
+    "foundryvtt",
+    "character-sheet",
+    "rpg"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "peerDependencies": {
+    "playwright": ">=1.45"
+  },
+  "peerDependenciesMeta": {
+    "playwright": {
+      "optional": true
+    }
+  }
+}

package/server.js

@@ -0,0 +1,136 @@
+import http from "node:http";
+import { WebSocketServer } from "ws";
+import { timingSafeEqual } from "node:crypto";
+import { staticHandler } from "./static.js";
+
+const PORT = process.env.PORT ?? 8787;
+const MAX_FAILS = 10, WINDOW_MS = 60_000;
+const pending = new Map();
+const fails = new Map(); // ip -> [timestamps de falhas de auth]
+let foundry = null; // conexão do módulo (Foundry)
+const subs = new Map(); // actorId -> Set(res): apps com a ficha aberta (Server-Sent Events)
+let seq = 0;
+
+const wss = new WebSocketServer({ noServer: true });
+wss.on("connection", (ws) => {
+  foundry = ws;
+  ws.on("message", (raw) => {
+    const m = JSON.parse(raw);
+    if (m.event === "actor") for (const r of subs.get(m.actorId) ?? []) r.write("data: changed\n\n");
+    else pending.get(m.id)?.(m);
+  });
+  ws.on("close", () => { if (foundry === ws) foundry = null; });
+});
+
+const ask = (msg) => new Promise((resolve, reject) => {
+  if (!foundry) return reject(Object.assign(new Error("Foundry disconnected"), { status: 503, code: "relay.disconnected" }));
+  const id = ++seq;
+  const t = setTimeout(() => { pending.delete(id); reject(Object.assign(new Error("timeout"), { status: 504 })); }, 60_000);
+  pending.set(id, (m) => { clearTimeout(t); pending.delete(id); resolve(m); });
+  foundry.send(JSON.stringify({ id, ...msg }));
+});
+
+// IP do jogador para o limite de tentativas. O relay só é acessível pelo Caddy (rede docker, sem porta no host), e o Caddy
+// sobrescreve o X-Forwarded-For com o IP real do cliente; sem isso todos os jogadores dividiam o IP do proxy e uma
+// sessão velha de um bloqueava a mesa inteira.
+// X-Forwarded-For só vale atrás de proxy confiável (TRUST_PROXY=1); direto na internet qualquer um forjaria o IP e burlaria o limite.
+const clientIp = (req) => (process.env.TRUST_PROXY && req.headers["x-forwarded-for"]?.split(",").at(-1).trim()) || req.socket.remoteAddress;
+
+const recentFails = (ip) => {
+  const l = (fails.get(ip) ?? []).filter((t) => Date.now() - t < WINDOW_MS);
+  fails.set(ip, l);
+  return l;
+};
+
+const routes = [
+  ["GET", /^\/api\/users$/, () => ({ type: "listUsers", public: true })],
+  ["GET", /^\/api\/status$/, () => ({ type: "status", public: true })], // sistema e plugin carregados no mundo (sem token)
+  ["GET", /^\/api\/characters$/, () => ({ type: "listCharacters" })],
+  ["GET", /^\/api\/character\/([\w-]+)$/, (m) => ({ type: "getCharacter", actorId: m[1] })],
+  ["GET", /^\/api\/packs$/, () => ({ type: "listPacks" })],
+  ["GET", /^\/api\/packs\/([\w.-]+)\/search$/, (m, body, url) => ({ type: "searchCompendium", pack: m[1], query: url.searchParams.get("q") ?? "" })],
+  // Rota genérica: qualquer comando do módulo, argumentos no corpo. É o que os apps novos (ex.: Avatar) usam;
+  // o módulo valida o comando e a permissão, então o relay não precisa conhecer cada um.
+  ["POST", /^\/api\/call\/(\w+)$/, (m, body) => { const { type: _t, token: _k, id: _i, ...args } = body ?? {}; return { ...args, type: m[1] }; }],
+  ["POST", /^\/api\/password$/, (m, body) => ({ type: "changePassword", oldPassword: body.oldPassword, newPassword: body.newPassword })],
+  // sem token: o único endpoint público; falhas contam no limite por IP
+  ["POST", /^\/api\/login$/, (m, body) => ({ type: "login", username: body.username, password: body.password, public: true })]
+];
+
+const MAX_BODY = 64 * 1024;
+// Corpo grande demais: drena sem guardar e rejeita no fim, para a resposta 413 chegar (destruir o socket vira "conexão caiu").
+const readJson = (req) => new Promise((resolve, reject) => {
+  let raw = "", big = false;
+  req.on("data", (c) => { if (big) return; raw += c; if (raw.length > MAX_BODY) { big = true; raw = ""; } });
+  req.on("error", () => resolve(null));
+  req.on("end", () => {
+    if (big) return reject(Object.assign(new Error("Request body too large"), { status: 413, code: "relay.bodyTooLarge" }));
+    try { resolve(JSON.parse(raw || "{}")); } catch { resolve(null); }
+  });
+});
+
+// STATIC_DIR (pasta do `expo export` de um sistema) faz o relay servir também o app em BASE_PATH (padrão /ficha). O app chama /sheet-api/...; /api/... continua valendo.
+const serveApp = process.env.STATIC_DIR ? staticHandler({ dir: process.env.STATIC_DIR, base: process.env.BASE_PATH ?? "/ficha" }) : null;
+
+export const server = http.createServer(async (req, res) => {
+  // Token em header (sem cookie), então "*" não abre brecha de CSRF.
+  const out = (s, body) => { res.writeHead(s, { "content-type": "application/json", "access-control-allow-origin": "*" }); res.end(JSON.stringify(body)); };
+  if (req.method === "OPTIONS") {
+    res.writeHead(204, { "access-control-allow-origin": "*", "access-control-allow-headers": "authorization,content-type", "access-control-allow-methods": "GET,PATCH,POST,OPTIONS" });
+    return res.end();
+  }
+  const ip = clientIp(req);
+  const url = new URL(req.url.replace(/^\/sheet-api(?=\/|$|\?)/, "/api"), "http://relay");
+  if (serveApp && req.method === "GET" && !url.pathname.startsWith("/api/") && await serveApp(url.pathname, res)) return;
+  const route = routes.map(([method, re, build]) => req.method === method && [url.pathname.match(re), build]).find((r) => r && r[0]);
+  if (url.pathname === "/api/events" && req.method === "GET") return events(req, res, url, ip, out);
+  if (!route) return out(404, { error: "Not found", code: "relay.notFound" });
+
+  if (recentFails(ip).length >= MAX_FAILS) return out(429, { error: "Too many attempts", code: "relay.tooManyAttempts" });
+  const token = req.headers.authorization?.match(/^Bearer (\S+)$/)?.[1];
+  const fail401 = (msg = "Invalid token", code = "relay.invalidToken") => { recentFails(ip).push(Date.now()); out(401, { error: msg, ...(code && { code }) }); };
+  const isPublic = route[1](route[0], {}, url).public;
+  if (!token && !isPublic) return fail401();
+
+  try {
+    const body = req.method === "GET" ? {} : await readJson(req);
+    if (!body) return out(400, { error: "Invalid JSON", code: "relay.badJson" });
+    const { public: _p, ...cmd } = route[1](route[0], body, url);
+    const r = await ask({ ...cmd, token });
+    if (r.status === 401) return fail401(r.error, r.code ?? null);
+    out(r.ok ? 200 : r.status ?? 500, r.ok ? r.data : { error: r.error, code: r.code });
+  } catch (e) { out(e.status ?? 500, { error: e.message, code: e.code }); }
+});
+// GET /api/events?actor=ID&t=TOKEN — EventSource não manda header, por isso o token vem na URL.
+// Mantém a conexão aberta e manda "changed" quando a ficha muda no Foundry.
+async function events(req, res, url, ip, out) {
+  if (recentFails(ip).length >= MAX_FAILS) return out(429, { error: "Too many attempts", code: "relay.tooManyAttempts" });
+  const actorId = url.searchParams.get("actor") ?? "", token = url.searchParams.get("t") ?? "";
+  if (!/^[\w-]+$/.test(actorId) || !token) { recentFails(ip).push(Date.now()); return out(401, { error: "Invalid token", code: "relay.invalidToken" }); }
+  try {
+    const r = await ask({ type: "subscribe", actorId, token });
+    if (!r.ok) { if (r.status === 401) recentFails(ip).push(Date.now()); return out(r.status ?? 500, { error: r.error, code: r.code }); }
+  } catch (e) { return out(e.status ?? 500, { error: e.message, code: e.code }); }
+  res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive", "access-control-allow-origin": "*" });
+  res.write(": ok\n\n");
+  if (!subs.has(actorId)) subs.set(actorId, new Set());
+  subs.get(actorId).add(res);
+  const beat = setInterval(() => res.write(": ping\n\n"), 25_000); // mantém proxies sem derrubar a conexão ociosa
+  req.on("close", () => { clearInterval(beat); subs.get(actorId)?.delete(res); if (!subs.get(actorId)?.size) subs.delete(actorId); });
+}
+
+// O módulo do Foundry é quem se conecta aqui e recebe logins e tokens: com RELAY_SECRET só quem tem o segredo entra.
+const secretOk = (req) => {
+  const want = process.env.RELAY_SECRET;
+  if (!want) return true;
+  const got = String(new URL(req.url, "http://x").searchParams.get("secret") ?? "");
+  const a = Buffer.from(got), b = Buffer.from(want);
+  return a.length === b.length && timingSafeEqual(a, b);
+};
+server.on("upgrade", (req, sock, head) => {
+  if (!secretOk(req)) { sock.write("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n"); return sock.destroy(); }
+  wss.handleUpgrade(req, sock, head, (ws) => wss.emit("connection", ws));
+});
+
+// Escuta só em localhost por padrão; no Docker, HOST=0.0.0.0 e só o Caddy (HTTPS) alcança a porta.
+if (import.meta.url === `file://${process.argv[1]}`) server.listen(PORT, process.env.HOST ?? "127.0.0.1", () => { console.log(`relay em :${PORT}`); if (!process.env.RELAY_SECRET) console.warn("AVISO: RELAY_SECRET não definido; qualquer um que alcance esta porta pode se passar pelo Foundry."); });

package/static.js

@@ -0,0 +1,29 @@
+// Serve o app web (expo export) sob BASE (padrão /ficha): arquivos estáticos + volta para index.html nas rotas do app.
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+
+const MIME = { ".html": "text/html; charset=utf-8", ".js": "text/javascript; charset=utf-8", ".json": "application/json", ".css": "text/css", ".png": "image/png", ".jpg": "image/jpeg", ".svg": "image/svg+xml", ".ico": "image/x-icon", ".webmanifest": "application/manifest+json", ".ttf": "font/ttf", ".woff2": "font/woff2", ".woff": "font/woff", ".map": "application/json", ".txt": "text/plain" };
+
+export function staticHandler({ dir, base = "/ficha" }) {
+  const root = path.resolve(dir);
+  const b = ("/" + base.replace(/^\/+|\/+$/g, "")).replace(/^\/$/, "");
+  /** @returns {Promise<boolean>} true se a requisição era do app (e já foi respondida) */
+  return async (pathname, res) => {
+    if (pathname === "/" && b) { res.writeHead(302, { location: `${b}/` }); res.end(); return true; }
+    if (b && pathname === b) { res.writeHead(302, { location: `${b}/` }); res.end(); return true; }
+    if (b && !pathname.startsWith(`${b}/`)) return false;
+    let rel;
+    try { rel = decodeURIComponent(pathname.slice(b.length)); } catch { res.writeHead(400); res.end(); return true; }
+    let file = path.join(root, rel);
+    if (file !== root && !file.startsWith(root + path.sep)) { res.writeHead(403); res.end(); return true; }
+    let st = await stat(file).catch(() => null);
+    if (st?.isDirectory()) { file = path.join(file, "index.html"); st = await stat(file).catch(() => null); }
+    if (!st && !path.extname(rel)) { file = path.join(root, "index.html"); st = await stat(file).catch(() => null); } // rota do app
+    if (!st) { res.writeHead(404, { "content-type": "text/plain" }); res.end("Not found"); return true; }
+    const ext = path.extname(file);
+    const immutable = /\/_expo\/static\//.test(file);
+    res.writeHead(200, { "content-type": MIME[ext] ?? "application/octet-stream", "cache-control": immutable ? "public, max-age=31536000, immutable" : "no-cache" });
+    res.end(await readFile(file));
+    return true;
+  };
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.