@goodea/echolet 0.1.0 → 0.1.1

package/web-dist/server.js

@@ -4,7 +4,7 @@ const require = createRequire(import.meta.url);
 
 // ../web/src/server/server.ts
 import http from "node:http";
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile as readFile2 } 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";
@@ -40,19 +40,37 @@ var CliBridge = class {
   async execute(argv, stdinInput) {
     return new Promise((res) => {
       const child = spawn(process.execPath, [this.options.cliPath, ...argv], {
-        env: process.env,
+        env: this.options.environment ?? process.env,
         stdio: ["pipe", "pipe", "pipe"]
       });
       let stdout = "";
       let stderr = "";
+      let settled = false;
+      const finish = (outcome) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        res(outcome);
+      };
+      const timeout = setTimeout(() => {
+        child.kill("SIGKILL");
+        finish({
+          ok: false,
+          code: "CLI_TIMEOUT",
+          exitCode: 1,
+          data: { error: "CLI command timed out" }
+        });
+      }, this.options.commandTimeoutMs ?? 15e3);
       child.stdout.on("data", (chunk) => {
         stdout += chunk.toString("utf8");
       });
       child.stderr.on("data", (chunk) => {
         stderr += chunk.toString("utf8");
       });
+      child.stdin.on("error", () => {
+      });
       child.on("error", (err) => {
-        res({
+        finish({
           ok: false,
           code: "SPAWN_ERROR",
           exitCode: 1,
@@ -65,7 +83,7 @@ var CliBridge = class {
           const trimmed = stdout.trim();
           if (trimmed.startsWith("{")) {
             const parsed = JSON.parse(trimmed);
-            res({
+            finish({
               ok: parsed.ok ?? code === 0,
               code: parsed.error?.code ?? (code === 0 ? "ok" : "ERROR"),
               exitCode: code,
@@ -75,7 +93,7 @@ var CliBridge = class {
           }
         } catch {
         }
-        res({
+        finish({
           ok: code === 0,
           code: code === 0 ? "ok" : "NON_ZERO_EXIT",
           exitCode: code,
@@ -137,6 +155,203 @@ var CliBridge = class {
       "--json"
     ]);
   }
+  async validateContact(cardPath) {
+    return this.execute([
+      "contact",
+      "import",
+      "--from",
+      cardPath,
+      "--profile",
+      this.options.profileDir,
+      "--json"
+    ], "no\n");
+  }
+};
+
+// ../web/src/server/contactCards.ts
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function objectValue(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function parseContactCardJson(input) {
+  let value = input;
+  if (typeof value === "string") {
+    try {
+      value = JSON.parse(value);
+    } catch {
+      return { ok: false, code: "INVALID_CONTACT_CARD", message: "Contact card is not valid JSON" };
+    }
+  }
+  const card = objectValue(value);
+  const signalBundle = objectValue(card?.signal_bundle);
+  const deviceRecord = objectValue(signalBundle?.device_record);
+  const identityId = deviceRecord?.identity_id;
+  const deviceId = deviceRecord?.device_id;
+  if (card?.type !== "echolet_contact_card" || card.version !== 1 || typeof identityId !== "string" || !identityId || typeof deviceId !== "string" || !deviceId) {
+    return {
+      ok: false,
+      code: "INVALID_CONTACT_CARD",
+      message: "Contact card is missing public identity fields"
+    };
+  }
+  return {
+    ok: true,
+    data: { card, preview: { identityId, deviceId } }
+  };
+}
+function errorDetail(outcome) {
+  const data = objectValue(outcome.data);
+  const error = objectValue(data?.error);
+  return typeof error?.detail === "string" ? error.detail : null;
+}
+function operationFailure(outcome) {
+  return {
+    ok: false,
+    code: outcome.code,
+    message: "Contact card operation failed",
+    outcome
+  };
+}
+function ioFailure() {
+  return { ok: false, code: "PERSISTENCE_FAILURE", message: "Temporary contact card storage failed" };
+}
+async function exportContactCard(bridge2, temporaryRoot = tmpdir()) {
+  let directory;
+  try {
+    directory = await mkdtemp(join(temporaryRoot, "echolet-web-export-"));
+    const outputPath = join(directory, "contact-card.json");
+    const outcome = await bridge2.exportContact(outputPath);
+    if (!outcome.ok) return operationFailure(outcome);
+    const contents = await readFile(outputPath, "utf8");
+    return parseContactCardJson(contents);
+  } catch {
+    return ioFailure();
+  } finally {
+    if (directory) await rm(directory, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+async function importContactCardJson(bridge2, cardJson, temporaryRoot = tmpdir()) {
+  const parsed = parseContactCardJson(cardJson);
+  if (!parsed.ok) return parsed;
+  let directory;
+  try {
+    directory = await mkdtemp(join(temporaryRoot, "echolet-web-import-"));
+    const inputPath = join(directory, "contact-card.json");
+    await writeFile(inputPath, JSON.stringify(parsed.data.card), { encoding: "utf8", flag: "wx", mode: 384 });
+    const outcome = await bridge2.importContact(inputPath);
+    if (!outcome.ok) return operationFailure(outcome);
+    return parsed;
+  } catch {
+    return ioFailure();
+  } finally {
+    if (directory) await rm(directory, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+async function validateContactCardJson(bridge2, cardJson, temporaryRoot = tmpdir()) {
+  const parsed = parseContactCardJson(cardJson);
+  if (!parsed.ok) return parsed;
+  let directory;
+  try {
+    directory = await mkdtemp(join(temporaryRoot, "echolet-web-validate-"));
+    const inputPath = join(directory, "contact-card.json");
+    await writeFile(inputPath, JSON.stringify(parsed.data.card), { encoding: "utf8", flag: "wx", mode: 384 });
+    const outcome = await bridge2.validateContact(inputPath);
+    const declinedAfterVerification = outcome.code === "CONTACT_NOT_CONFIRMED" || outcome.code === "TRUST_FAILURE" && errorDetail(outcome) === "CONTACT_NOT_CONFIRMED";
+    return declinedAfterVerification ? parsed : operationFailure(outcome);
+  } catch {
+    return ioFailure();
+  } finally {
+    if (directory) await rm(directory, { recursive: true, force: true }).catch(() => void 0);
+  }
+}
+
+// ../web/src/server/stationApi.ts
+function createStatusPayload(label, snapshot) {
+  return { label, ...snapshot };
+}
+function validationFailureHttpStatus(code) {
+  if (code === "INVALID_CONTACT_CARD" || code === "TRUST_FAILURE") return 400;
+  if (code === "CLI_TIMEOUT") return 504;
+  return 500;
+}
+
+// ../web/src/server/stationStatus.ts
+function recordValue(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+var StationStatus = class {
+  constructor(options) {
+    this.options = options;
+    this.fetchImpl = options.fetch ?? fetch;
+    this.now = options.now ?? Date.now;
+    this.statusUpdatedAt = new Date(this.now()).toISOString();
+  }
+  fetchImpl;
+  now;
+  profile = null;
+  profileState = "unknown";
+  relay = "unknown";
+  relayReachability = "unknown";
+  pingMs = null;
+  statusUpdatedAt;
+  profileRefreshGeneration = 0;
+  relayRefreshGeneration = 0;
+  async refreshProfile() {
+    const generation = ++this.profileRefreshGeneration;
+    const outcome = await this.options.doctor();
+    const profile = outcome.ok ? recordValue(outcome.data) : null;
+    if (generation !== this.profileRefreshGeneration) return;
+    this.profile = profile;
+    this.profileState = profile ? "verified" : outcome.code === "SPAWN_ERROR" || outcome.code === "CLI_TIMEOUT" ? "unknown" : "unverified";
+    this.touch();
+  }
+  async refreshRelayReachability() {
+    const generation = ++this.relayRefreshGeneration;
+    const startedAt = this.now();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.options.healthTimeoutMs ?? 3e3);
+    let relayReachability = "unreachable";
+    let pingMs = null;
+    try {
+      const response = await this.fetchImpl(`${this.options.relayUrl}/health`, { signal: controller.signal });
+      if (response.ok) {
+        relayReachability = "reachable";
+        pingMs = Math.max(0, this.now() - startedAt);
+      }
+    } catch {
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (generation !== this.relayRefreshGeneration) return;
+    this.relayReachability = relayReachability;
+    this.pingMs = pingMs;
+    this.touch();
+  }
+  recordPoll(outcome) {
+    if (outcome.ok) this.relay = "connected";
+    else if (outcome.code === "RELAY_UNAVAILABLE" || outcome.code === "CLI_TIMEOUT" || outcome.code === "SPAWN_ERROR") {
+      this.relay = "disconnected";
+    } else {
+      this.relay = "unknown";
+    }
+    this.touch();
+  }
+  snapshot() {
+    return {
+      profile: this.profile,
+      profileState: this.profileState,
+      relay: this.relay,
+      relayReachability: this.relayReachability,
+      relayUrl: this.options.relayUrl,
+      pingMs: this.pingMs,
+      statusUpdatedAt: this.statusUpdatedAt
+    };
+  }
+  touch() {
+    this.statusUpdatedAt = new Date(this.now()).toISOString();
+  }
 };
 
 // ../web/src/server/server.ts
@@ -182,6 +397,10 @@ var bridge = new CliBridge({
   storeKeyEnv: config.storeKeyEnv,
   relayUrl: config.relayUrl
 });
+var stationStatus = new StationStatus({
+  doctor: () => bridge.doctor(),
+  relayUrl: config.relayUrl
+});
 var telemetryLogs = [];
 function logTelemetry(type, message) {
   const now = /* @__PURE__ */ new Date();
@@ -206,24 +425,16 @@ data: ${JSON.stringify(data)}
     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;
+function statusPayload() {
+  return createStatusPayload(config.label, stationStatus.snapshot());
+}
+function broadcastStatus() {
+  broadcastSSE("status", statusPayload());
+}
+function numericField(value, key) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
+  const field = value[key];
+  return typeof field === "number" && Number.isFinite(field) ? field : null;
 }
 var polling = false;
 async function pollLoop() {
@@ -231,8 +442,10 @@ async function pollLoop() {
   polling = true;
   try {
     const outcome = await bridge.poll();
+    stationStatus.recordPoll(outcome);
+    broadcastStatus();
     if (outcome.ok && outcome.data) {
-      const received = outcome.data.received ?? 0;
+      const received = numericField(outcome.data, "received") ?? 0;
       if (received > 0) {
         logTelemetry("success", `[Inbound] ${received} new encrypted message(s) downloaded from relay`);
         broadcastSSE("new_message", { received });
@@ -240,36 +453,41 @@ async function pollLoop() {
     } else if (!outcome.ok) {
       logTelemetry("warn", `[Poll Warning] ${outcome.code}`);
     }
-  } catch (err) {
-    logTelemetry("error", `[Poll Error] ${err.message}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown poll error";
+    logTelemetry("error", `[Poll Error] ${message}`);
   } finally {
     polling = false;
   }
 }
 setInterval(pollLoop, 2500);
 setInterval(async () => {
-  const ping = await checkRelayPing();
-  if (ping !== null) {
-    broadcastSSE("ping", { ping, status: "healthy" });
+  await stationStatus.refreshRelayReachability();
+  const snapshot = statusPayload();
+  if (snapshot.pingMs !== null) {
+    broadcastSSE("ping", { ping: snapshot.pingMs, status: "reachable" });
   } else {
     broadcastSSE("ping", { ping: null, status: "unreachable" });
   }
+  broadcastStatus();
 }, 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`);
+  await stationStatus.refreshRelayReachability();
+  const snapshot = statusPayload();
+  if (snapshot.pingMs !== null) {
+    logTelemetry("success", `Relay reachable: ${snapshot.pingMs}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}`);
+  await stationStatus.refreshProfile();
+  const profile = statusPayload().profile;
+  const identityId = typeof profile?.identity_id === "string" ? profile.identity_id : "";
+  if (profile) {
+    logTelemetry("crypto", `Identity verified: ${identityId.substring(0, 16)}...`);
+    logTelemetry("info", `Pinned contacts count: ${numericField(profile, "contact_count") ?? 0}`);
   }
 })();
 var MIME_TYPES = {
@@ -281,20 +499,57 @@ var MIME_TYPES = {
   ".png": "image/png",
   ".jpg": "image/jpeg"
 };
+var MAX_JSON_BODY_BYTES = 128 * 1024;
+var RequestBodyError = class extends Error {
+  constructor(statusCode, code, message) {
+    super(message);
+    this.statusCode = statusCode;
+    this.code = code;
+  }
+};
 async function readBody(req) {
   return new Promise((res, rej) => {
     let body = "";
-    req.on("data", (chunk) => body += chunk);
+    let bytes = 0;
+    let settled = false;
+    req.on("data", (chunk) => {
+      if (settled) return;
+      bytes += chunk.length;
+      if (bytes > MAX_JSON_BODY_BYTES) {
+        settled = true;
+        req.resume();
+        rej(new RequestBodyError(413, "PAYLOAD_TOO_LARGE", "JSON body exceeds 128 KiB"));
+        return;
+      }
+      body += chunk.toString("utf8");
+    });
     req.on("end", () => {
+      if (settled) return;
       try {
-        res(body ? JSON.parse(body) : {});
-      } catch (err) {
-        rej(err);
+        const parsed = body ? JSON.parse(body) : {};
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+          rej(new RequestBodyError(400, "INVALID_JSON_BODY", "JSON body must be an object"));
+          return;
+        }
+        res(parsed);
+      } catch {
+        rej(new RequestBodyError(400, "INVALID_JSON_BODY", "JSON body is malformed"));
       }
     });
     req.on("error", rej);
   });
 }
+function writeJson(res, statusCode, value) {
+  res.writeHead(statusCode, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(value));
+}
+function writeRequestError(res, error) {
+  if (error instanceof RequestBodyError) {
+    writeJson(res, error.statusCode, { ok: false, code: error.code, error: error.message });
+    return;
+  }
+  writeJson(res, 500, { ok: false, code: "INTERNAL_ERROR", error: "Request failed" });
+}
 var server = http.createServer(async (req, res) => {
   const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
   const pathname = url.pathname;
@@ -312,25 +567,24 @@ var server = http.createServer(async (req, res) => {
       "Cache-Control": "no-cache",
       Connection: "keep-alive"
     });
-    res.write("\n");
+    res.write(`event: status
+data: ${JSON.stringify(statusPayload())}
+
+`);
     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({
+    await Promise.all([
+      stationStatus.refreshProfile(),
+      stationStatus.refreshRelayReachability()
+    ]);
+    writeJson(res, 200, {
       ok: true,
-      label: config.label,
-      profile: cachedProfile,
-      relayUrl: config.relayUrl,
-      pingMs: lastPingMs,
+      ...statusPayload(),
       telemetry: telemetryLogs.slice(-50)
-    }));
+    });
     return;
   }
   if (pathname === "/api/history" && req.method === "GET") {
@@ -348,13 +602,15 @@ var server = http.createServer(async (req, res) => {
   if (pathname === "/api/send" && req.method === "POST") {
     try {
       const body = await readBody(req);
-      if (!body.to || !body.text) {
+      const to = typeof body.to === "string" ? body.to : "";
+      const text = typeof body.text === "string" ? body.text : "";
+      if (!to || !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);
+      logTelemetry("crypto", `Encrypting message via Double Ratchet for recipient ${to.substring(0, 12)}...`);
+      const outcome = await bridge.send(to, text);
       if (outcome.ok) {
         logTelemetry("success", `[Outbound] Envelope delivered to relay (status: ${outcome.data?.status})`);
         broadcastSSE("outbound_sent", outcome.data);
@@ -382,46 +638,61 @@ var server = http.createServer(async (req, res) => {
     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);
+    const result = await exportContactCard(bridge);
+    if (result.ok) {
+      writeJson(res, 200, result.data.card);
       return;
     }
-    res.writeHead(500, { "Content-Type": "application/json" });
-    res.end(JSON.stringify(outcome));
+    logTelemetry("error", `Contact export failed: ${result.code}`);
+    writeJson(res, 500, { ok: false, code: result.code, error: result.message });
+    return;
+  }
+  if (pathname === "/api/contacts/validate" && req.method === "POST") {
+    try {
+      const body = await readBody(req);
+      const result = await validateContactCardJson(bridge, body.cardJson);
+      if (!result.ok) {
+        writeJson(res, validationFailureHttpStatus(result.code), {
+          ok: false,
+          code: result.code,
+          error: result.message
+        });
+        return;
+      }
+      writeJson(res, 200, { ok: true, data: { preview: result.data.preview } });
+    } catch (error) {
+      writeRequestError(res, error);
+    }
     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 (body.cardJson === void 0) {
+        writeJson(res, 400, { ok: false, code: "MISSING_CONTACT_CARD", error: "Missing cardJson" });
+        return;
       }
-      if (!cardPath) {
-        res.writeHead(400, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ ok: false, error: "Missing cardPath or cardJson" }));
+      if (body.confirmed !== true) {
+        writeJson(res, 409, { ok: false, code: "CONFIRMATION_REQUIRED", error: "Confirm the validated contact card before import" });
         return;
       }
       logTelemetry("crypto", `Verifying contact card cryptographic signatures...`);
-      const outcome = await bridge.importContact(cardPath);
-      if (outcome.ok) {
+      const result = await importContactCardJson(bridge, body.cardJson);
+      if (result.ok) {
         logTelemetry("success", `Contact trusted & added to secure address book`);
-        const doc = await bridge.doctor();
-        if (doc.ok) cachedProfile = doc.data;
+        await stationStatus.refreshProfile();
         broadcastSSE("contact_added", {});
+        broadcastStatus();
       } else {
-        logTelemetry("error", `Contact import failed: ${outcome.code}`);
+        logTelemetry("error", `Contact import failed: ${result.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 }));
+      writeJson(
+        res,
+        result.ok ? 200 : result.code === "INVALID_CONTACT_CARD" || result.code === "TRUST_FAILURE" ? 400 : 500,
+        result.ok ? { ok: true, code: "ok", data: { preview: result.data.preview } } : { ok: false, code: result.code, error: result.message }
+      );
+    } catch (error) {
+      writeRequestError(res, error);
     }
     return;
   }
@@ -434,7 +705,7 @@ var server = http.createServer(async (req, res) => {
     const ext = extname(target).toLowerCase();
     const contentType = MIME_TYPES[ext] || "application/octet-stream";
     try {
-      const content = await readFile(target);
+      const content = await readFile2(target);
       res.writeHead(200, { "Content-Type": contentType });
       res.end(content);
       return;