@goodea/echolet 0.1.0

package/web-dist/server.js

@@ -0,0 +1,460 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+
+// ../web/src/server/server.ts
+import http from "node:http";
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
+import { resolve as resolve2, extname, dirname as dirname2 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+
+// ../web/src/server/cliBridge.ts
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+var HERE = dirname(fileURLToPath(import.meta.url));
+function resolveCliPath(overridePath) {
+  if (overridePath && existsSync(overridePath)) {
+    return overridePath;
+  }
+  if (process.env.ECHOLET_CLI_PATH && existsSync(process.env.ECHOLET_CLI_PATH)) {
+    return process.env.ECHOLET_CLI_PATH;
+  }
+  const flattenedNpmPath = resolve(HERE, "./cli.js");
+  if (existsSync(flattenedNpmPath)) {
+    return flattenedNpmPath;
+  }
+  const siblingDistPath = resolve(HERE, "../cli/dist/cli.js");
+  if (existsSync(siblingDistPath)) {
+    return siblingDistPath;
+  }
+  return resolve(HERE, "../../cli/dist/cli.js");
+}
+var DEFAULT_CLI_PATH = resolveCliPath();
+var CliBridge = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async execute(argv, stdinInput) {
+    return new Promise((res) => {
+      const child = spawn(process.execPath, [this.options.cliPath, ...argv], {
+        env: process.env,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString("utf8");
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString("utf8");
+      });
+      child.on("error", (err) => {
+        res({
+          ok: false,
+          code: "SPAWN_ERROR",
+          exitCode: 1,
+          data: { error: err.message }
+        });
+      });
+      child.on("close", (exitCode) => {
+        const code = exitCode ?? 0;
+        try {
+          const trimmed = stdout.trim();
+          if (trimmed.startsWith("{")) {
+            const parsed = JSON.parse(trimmed);
+            res({
+              ok: parsed.ok ?? code === 0,
+              code: parsed.error?.code ?? (code === 0 ? "ok" : "ERROR"),
+              exitCode: code,
+              data: parsed.data ?? parsed
+            });
+            return;
+          }
+        } catch {
+        }
+        res({
+          ok: code === 0,
+          code: code === 0 ? "ok" : "NON_ZERO_EXIT",
+          exitCode: code,
+          data: { stdout, stderr }
+        });
+      });
+      if (stdinInput !== void 0) {
+        child.stdin.end(stdinInput, "utf8");
+      } else {
+        child.stdin.end();
+      }
+    });
+  }
+  async doctor() {
+    return this.execute(["doctor", "--profile", this.options.profileDir, "--json"]);
+  }
+  async poll() {
+    return this.execute(["poll", "--profile", this.options.profileDir, "--json"]);
+  }
+  async history(contactIdentityId) {
+    return this.execute([
+      "history",
+      "--with",
+      contactIdentityId,
+      "--profile",
+      this.options.profileDir,
+      "--json"
+    ]);
+  }
+  async send(toIdentityId, text) {
+    return this.execute(
+      ["send", "--to", toIdentityId, "--profile", this.options.profileDir, "--json"],
+      text
+    );
+  }
+  async publish() {
+    return this.execute(["relay", "publish", "--profile", this.options.profileDir, "--json"]);
+  }
+  async exportContact(outPath) {
+    return this.execute([
+      "contact",
+      "export",
+      "--out",
+      outPath,
+      "--profile",
+      this.options.profileDir,
+      "--json"
+    ]);
+  }
+  async importContact(cardPath) {
+    return this.execute([
+      "contact",
+      "import",
+      "--from",
+      cardPath,
+      "--yes",
+      "--profile",
+      this.options.profileDir,
+      "--json"
+    ]);
+  }
+};
+
+// ../web/src/server/server.ts
+var HERE2 = dirname2(fileURLToPath2(import.meta.url));
+var CLIENT_DIST = resolve2(HERE2, "client");
+function parseArgv() {
+  const argv = process.argv.slice(2);
+  let port = 3e3;
+  let profileDir = resolve2(process.cwd(), ".tmp/demo-data/alice");
+  let label = "Operator";
+  let relayUrl = "https://depr.tail5a88fb.ts.net:8443";
+  let storeKeyEnv = "ECHOLET_STORE_KEY";
+  let cliPath = DEFAULT_CLI_PATH;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    if (arg === "--port" && next) {
+      port = parseInt(next, 10);
+      i++;
+    } else if (arg === "--profile" && next) {
+      profileDir = resolve2(next);
+      i++;
+    } else if (arg === "--label" && next) {
+      label = next;
+      i++;
+    } else if (arg === "--relay-url" && next) {
+      relayUrl = next;
+      i++;
+    } else if (arg === "--store-key-env" && next) {
+      storeKeyEnv = next;
+      i++;
+    } else if (arg === "--cli" && next) {
+      cliPath = resolve2(next);
+      i++;
+    }
+  }
+  return { port, profileDir, label, relayUrl, storeKeyEnv, cliPath };
+}
+var config = parseArgv();
+var bridge = new CliBridge({
+  cliPath: config.cliPath,
+  profileDir: config.profileDir,
+  storeKeyEnv: config.storeKeyEnv,
+  relayUrl: config.relayUrl
+});
+var telemetryLogs = [];
+function logTelemetry(type, message) {
+  const now = /* @__PURE__ */ new Date();
+  const time = now.toTimeString().split(" ")[0] + "." + String(now.getMilliseconds()).padStart(3, "0");
+  const item = {
+    id: Math.random().toString(36).substring(2, 9),
+    time,
+    type,
+    message
+  };
+  telemetryLogs.push(item);
+  if (telemetryLogs.length > 200) telemetryLogs.shift();
+  broadcastSSE("telemetry", item);
+}
+var sseClients = /* @__PURE__ */ new Set();
+function broadcastSSE(event, data) {
+  const payload = `event: ${event}
+data: ${JSON.stringify(data)}
+
+`;
+  for (const client of sseClients) {
+    client.write(payload);
+  }
+}
+var cachedProfile = null;
+var lastPingMs = null;
+async function checkRelayPing() {
+  const start = Date.now();
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    const res = await fetch(`${config.relayUrl}/health`, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (res.ok) {
+      const ping = Date.now() - start;
+      lastPingMs = ping;
+      return ping;
+    }
+  } catch {
+    lastPingMs = null;
+  }
+  return null;
+}
+var polling = false;
+async function pollLoop() {
+  if (polling) return;
+  polling = true;
+  try {
+    const outcome = await bridge.poll();
+    if (outcome.ok && outcome.data) {
+      const received = outcome.data.received ?? 0;
+      if (received > 0) {
+        logTelemetry("success", `[Inbound] ${received} new encrypted message(s) downloaded from relay`);
+        broadcastSSE("new_message", { received });
+      }
+    } else if (!outcome.ok) {
+      logTelemetry("warn", `[Poll Warning] ${outcome.code}`);
+    }
+  } catch (err) {
+    logTelemetry("error", `[Poll Error] ${err.message}`);
+  } finally {
+    polling = false;
+  }
+}
+setInterval(pollLoop, 2500);
+setInterval(async () => {
+  const ping = await checkRelayPing();
+  if (ping !== null) {
+    broadcastSSE("ping", { ping, status: "healthy" });
+  } else {
+    broadcastSSE("ping", { ping: null, status: "unreachable" });
+  }
+}, 5e3);
+(async () => {
+  logTelemetry("crypto", `Initializing Echolet Web Node for [${config.label}]`);
+  logTelemetry("info", `Profile store: ${config.profileDir}`);
+  logTelemetry("info", `Target relay: ${config.relayUrl}`);
+  const ping = await checkRelayPing();
+  if (ping !== null) {
+    logTelemetry("success", `Connected to Relay: ${ping}ms latency`);
+  } else {
+    logTelemetry("warn", `Relay unreachable or checking...`);
+  }
+  const doc = await bridge.doctor();
+  if (doc.ok) {
+    cachedProfile = doc.data;
+    logTelemetry("crypto", `Identity verified: ${doc.data.identity_id?.substring(0, 16)}...`);
+    logTelemetry("info", `Pinned contacts count: ${doc.data.contact_count ?? 0}`);
+  }
+})();
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg"
+};
+async function readBody(req) {
+  return new Promise((res, rej) => {
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", () => {
+      try {
+        res(body ? JSON.parse(body) : {});
+      } catch (err) {
+        rej(err);
+      }
+    });
+    req.on("error", rej);
+  });
+}
+var server = http.createServer(async (req, res) => {
+  const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+  const pathname = url.pathname;
+  res.setHeader("Access-Control-Allow-Origin", "*");
+  res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+  if (req.method === "OPTIONS") {
+    res.writeHead(204);
+    res.end();
+    return;
+  }
+  if (pathname === "/api/events") {
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    });
+    res.write("\n");
+    sseClients.add(res);
+    req.on("close", () => sseClients.delete(res));
+    return;
+  }
+  if (pathname === "/api/status" && req.method === "GET") {
+    if (!cachedProfile) {
+      const doc = await bridge.doctor();
+      if (doc.ok) cachedProfile = doc.data;
+    }
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({
+      ok: true,
+      label: config.label,
+      profile: cachedProfile,
+      relayUrl: config.relayUrl,
+      pingMs: lastPingMs,
+      telemetry: telemetryLogs.slice(-50)
+    }));
+    return;
+  }
+  if (pathname === "/api/history" && req.method === "GET") {
+    const withId = url.searchParams.get("with");
+    if (!withId) {
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: false, error: "Missing 'with' parameter" }));
+      return;
+    }
+    const outcome = await bridge.history(withId);
+    res.writeHead(outcome.ok ? 200 : 500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(outcome));
+    return;
+  }
+  if (pathname === "/api/send" && req.method === "POST") {
+    try {
+      const body = await readBody(req);
+      if (!body.to || !body.text) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: "Missing 'to' or 'text'" }));
+        return;
+      }
+      logTelemetry("crypto", `Encrypting message via Double Ratchet for recipient ${body.to.substring(0, 12)}...`);
+      const outcome = await bridge.send(body.to, body.text);
+      if (outcome.ok) {
+        logTelemetry("success", `[Outbound] Envelope delivered to relay (status: ${outcome.data?.status})`);
+        broadcastSSE("outbound_sent", outcome.data);
+      } else {
+        logTelemetry("error", `Send failure: ${outcome.code}`);
+      }
+      res.writeHead(outcome.ok ? 200 : 500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(outcome));
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: false, error: err.message }));
+    }
+    return;
+  }
+  if (pathname === "/api/publish" && req.method === "POST") {
+    logTelemetry("crypto", `Minting and publishing Signal PreKey Bundles...`);
+    const outcome = await bridge.publish();
+    if (outcome.ok) {
+      logTelemetry("success", `PreKey pool updated: target 20, claimable 20`);
+    } else {
+      logTelemetry("error", `Publish failed: ${outcome.code}`);
+    }
+    res.writeHead(outcome.ok ? 200 : 500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(outcome));
+    return;
+  }
+  if (pathname === "/api/contacts/export" && req.method === "GET") {
+    const tmpOut = resolve2(config.profileDir, "../export-temp.json");
+    const outcome = await bridge.exportContact(tmpOut);
+    if (outcome.ok && existsSync2(tmpOut)) {
+      const cardJson = await readFile(tmpOut, "utf8");
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(cardJson);
+      return;
+    }
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(outcome));
+    return;
+  }
+  if (pathname === "/api/contacts/import" && req.method === "POST") {
+    try {
+      const body = await readBody(req);
+      let cardPath = body.cardPath;
+      if (body.cardJson) {
+        cardPath = resolve2(config.profileDir, "../import-temp.json");
+        await writeFile(cardPath, typeof body.cardJson === "string" ? body.cardJson : JSON.stringify(body.cardJson), "utf8");
+      }
+      if (!cardPath) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, error: "Missing cardPath or cardJson" }));
+        return;
+      }
+      logTelemetry("crypto", `Verifying contact card cryptographic signatures...`);
+      const outcome = await bridge.importContact(cardPath);
+      if (outcome.ok) {
+        logTelemetry("success", `Contact trusted & added to secure address book`);
+        const doc = await bridge.doctor();
+        if (doc.ok) cachedProfile = doc.data;
+        broadcastSSE("contact_added", {});
+      } else {
+        logTelemetry("error", `Contact import failed: ${outcome.code}`);
+      }
+      res.writeHead(outcome.ok ? 200 : 500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(outcome));
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ ok: false, error: err.message }));
+    }
+    return;
+  }
+  let filePath = pathname === "/" ? "index.html" : pathname.replace(/^\//, "");
+  let target = resolve2(CLIENT_DIST, filePath);
+  if (!existsSync2(target)) {
+    target = resolve2(CLIENT_DIST, "index.html");
+  }
+  if (existsSync2(target)) {
+    const ext = extname(target).toLowerCase();
+    const contentType = MIME_TYPES[ext] || "application/octet-stream";
+    try {
+      const content = await readFile(target);
+      res.writeHead(200, { "Content-Type": contentType });
+      res.end(content);
+      return;
+    } catch {
+      res.writeHead(500);
+      res.end("Error loading file");
+      return;
+    }
+  }
+  res.writeHead(404);
+  res.end("Not Found");
+});
+server.listen(config.port, () => {
+  console.log(`
+=====================================================`);
+  console.log(`  ECHOLET WEB CLIENT \u2014 ${config.label}`);
+  console.log(`=====================================================`);
+  console.log(`  Local URL:   http://localhost:${config.port}`);
+  console.log(`  Profile:     ${config.profileDir}`);
+  console.log(`  Relay URL:   ${config.relayUrl}`);
+  console.log(`=====================================================
+`);
+});