codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/mdns-service.js

@@ -0,0 +1,304 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mdns_service_exports = {};
+__export(mdns_service_exports, {
+  getDiscoveredPeer: () => getDiscoveredPeer,
+  getDiscoveredPeers: () => getDiscoveredPeers,
+  getInstanceId: () => getInstanceId,
+  isMdnsRunning: () => isMdnsRunning,
+  onPeerDiscovered: () => onPeerDiscovered,
+  onPeerLost: () => onPeerLost,
+  startMdns: () => startMdns,
+  stopMdns: () => stopMdns,
+  updateAdvertisedName: () => updateAdvertisedName
+});
+module.exports = __toCommonJS(mdns_service_exports);
+var import_node_os = __toESM(require("node:os"));
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+var import_build_info = require("../../shared/build-info");
+var import_persistence = require("./persistence");
+let Bonjour = null;
+const SERVICE_TYPE = "codetrellis";
+const STALE_PEER_MS = 12e4;
+const BASE_ID_FILE = "mdns-instance-id";
+const INSTANCES_FILE = "mdns-instances.json";
+function isPidAlive(pid) {
+  if (!pid || pid === process.pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function readLiveInstances(dir) {
+  try {
+    const arr = JSON.parse(import_node_fs.default.readFileSync(import_node_path.default.join(dir, INSTANCES_FILE), "utf-8"));
+    return Array.isArray(arr) ? arr.filter((e) => e && typeof e.id === "string" && typeof e.pid === "number") : [];
+  } catch {
+    return [];
+  }
+}
+function writeLiveInstances(dir, list) {
+  try {
+    import_node_fs.default.mkdirSync(dir, { recursive: true });
+    const tmp = import_node_path.default.join(dir, `${INSTANCES_FILE}.tmp`);
+    import_node_fs.default.writeFileSync(tmp, JSON.stringify(list), "utf-8");
+    import_node_fs.default.renameSync(tmp, import_node_path.default.join(dir, INSTANCES_FILE));
+  } catch {
+  }
+}
+function loadStableBaseId(dir) {
+  try {
+    const file = import_node_path.default.join(dir, BASE_ID_FILE);
+    if (import_node_fs.default.existsSync(file)) {
+      const existing = import_node_fs.default.readFileSync(file, "utf-8").trim();
+      if (/^[0-9a-f]{8}$/i.test(existing)) return existing;
+    }
+    const id = (0, import_node_crypto.randomUUID)().slice(0, 8);
+    import_node_fs.default.mkdirSync(dir, { recursive: true });
+    import_node_fs.default.writeFileSync(file, id, "utf-8");
+    return id;
+  } catch {
+    return (0, import_node_crypto.randomUUID)().slice(0, 8);
+  }
+}
+function acquireInstanceId() {
+  let dir;
+  try {
+    dir = (0, import_persistence.getSettingsDir)();
+  } catch {
+    return (0, import_node_crypto.randomUUID)().slice(0, 8);
+  }
+  const baseId = loadStableBaseId(dir);
+  const live = readLiveInstances(dir).filter((e) => isPidAlive(e.pid));
+  const taken = new Set(live.map((e) => e.id));
+  let chosen = baseId;
+  if (taken.has(chosen)) {
+    for (let i = 0; i < 50 && taken.has(chosen); i++) {
+      chosen = `${baseId}${(0, import_node_crypto.randomUUID)().slice(0, 2)}`.slice(0, 12);
+    }
+    if (taken.has(chosen)) chosen = (0, import_node_crypto.randomUUID)().slice(0, 8);
+    console.log(`[mDNS] Base id ${baseId} held by a live instance \u2014 using ${chosen} to avoid an A-record collision.`);
+  }
+  writeLiveInstances(dir, [...live, { id: chosen, pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() }]);
+  return chosen;
+}
+function releaseInstanceId() {
+  try {
+    const dir = (0, import_persistence.getSettingsDir)();
+    writeLiveInstances(dir, readLiveInstances(dir).filter((e) => e.pid !== process.pid && isPidAlive(e.pid)));
+  } catch {
+  }
+}
+const instanceId = acquireInstanceId();
+process.once("exit", () => releaseInstanceId());
+let bonjourInstance = null;
+let publishedService = null;
+let browser = null;
+let sweepInterval = null;
+const peers = /* @__PURE__ */ new Map();
+const listeners = {
+  discovered: /* @__PURE__ */ new Set(),
+  lost: /* @__PURE__ */ new Set()
+};
+function getInstanceId() {
+  return instanceId;
+}
+function startMdns(deviceName, fingerprint, mobileApiPort) {
+  stopMdns();
+  try {
+    if (!Bonjour) {
+      const mod = require("bonjour-service");
+      Bonjour = mod.default ?? mod.Bonjour ?? mod;
+    }
+    bonjourInstance = new Bonjour();
+  } catch (err) {
+    console.warn("[mDNS] Failed to initialise bonjour-service \u2014 discovery disabled:", err);
+    return;
+  }
+  const name = deviceName || import_node_os.default.hostname();
+  const version = import_build_info.BUILD_INFO?.version ?? "0.0.0";
+  const fp = fingerprint || "pending";
+  const advertisePort = mobileApiPort && mobileApiPort > 0 ? mobileApiPort : 1;
+  try {
+    publishedService = bonjourInstance.publish({
+      name: `${name} (${instanceId})`,
+      type: SERVICE_TYPE,
+      // Advertise under a unique, CodeTrellis-owned hostname rather than the
+      // machine's real `.local` name. bonjour-service runs its own mDNS
+      // responder and announces A-records for `host`; if that's the system
+      // hostname (the default), it collides with macOS's built-in Bonjour
+      // responder, which resolves the conflict by renaming the Mac to
+      // "…-2.local", "…-3.local" on every (especially unclean) restart.
+      // A dedicated host keeps discovery working (peers read the IP from the
+      // record's addresses) without ever touching the OS hostname.
+      host: `codetrellis-${instanceId}.local`,
+      port: advertisePort,
+      txt: {
+        instanceId,
+        version,
+        fingerprint: fp,
+        deviceName: name,
+        mobileApiPort: String(advertisePort)
+      }
+    });
+    console.log(`[mDNS] Advertising as "${name}" (${instanceId}) mobileApiPort=${advertisePort}`);
+  } catch (err) {
+    console.warn("[mDNS] Failed to publish service:", err);
+  }
+  try {
+    browser = bonjourInstance.find({ type: SERVICE_TYPE });
+    browser.on("up", (service) => {
+      const txt = service.txt ?? {};
+      const peerInstanceId = txt.instanceId;
+      if (!peerInstanceId || peerInstanceId === instanceId) return;
+      const address = service.addresses?.[0] ?? service.host ?? "";
+      const peer = {
+        instanceId: peerInstanceId,
+        name: txt.deviceName || "Unknown",
+        version: txt.version || "?",
+        fingerprint: txt.fingerprint || "",
+        address,
+        lastSeen: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const isNew = !peers.has(peerInstanceId);
+      peers.set(peerInstanceId, peer);
+      if (isNew) {
+        console.log(`[mDNS] Discovered peer: "${peer.name}" at ${peer.address}`);
+        for (const cb of listeners.discovered) {
+          try {
+            cb(peer);
+          } catch {
+          }
+        }
+      }
+    });
+    browser.on("down", (service) => {
+      const txt = service.txt ?? {};
+      const peerInstanceId = txt.instanceId;
+      if (!peerInstanceId) return;
+      const peer = peers.get(peerInstanceId);
+      if (peer) {
+        peers.delete(peerInstanceId);
+        console.log(`[mDNS] Lost peer: "${peer.name}"`);
+        for (const cb of listeners.lost) {
+          try {
+            cb(peer);
+          } catch {
+          }
+        }
+      }
+    });
+    console.log(`[mDNS] Browsing for _${SERVICE_TYPE}._tcp services`);
+  } catch (err) {
+    console.warn("[mDNS] Failed to start browser:", err);
+  }
+  sweepInterval = setInterval(() => {
+    const cutoff = Date.now() - STALE_PEER_MS;
+    for (const [id, peer] of peers) {
+      if (new Date(peer.lastSeen).getTime() < cutoff) {
+        peers.delete(id);
+        console.log(`[mDNS] Stale peer removed: "${peer.name}"`);
+        for (const cb of listeners.lost) {
+          try {
+            cb(peer);
+          } catch {
+          }
+        }
+      }
+    }
+  }, 3e4);
+}
+function stopMdns() {
+  if (sweepInterval) {
+    clearInterval(sweepInterval);
+    sweepInterval = null;
+  }
+  if (publishedService) {
+    try {
+      publishedService.stop?.();
+    } catch {
+    }
+    publishedService = null;
+  }
+  if (browser) {
+    try {
+      browser.stop();
+    } catch {
+    }
+    browser = null;
+  }
+  if (bonjourInstance) {
+    try {
+      bonjourInstance.destroy();
+    } catch {
+    }
+    bonjourInstance = null;
+  }
+  peers.clear();
+}
+function updateAdvertisedName(name, fingerprint, mobileApiPort) {
+  if (!bonjourInstance) return;
+  startMdns(name, fingerprint, mobileApiPort);
+}
+function getDiscoveredPeers() {
+  return Array.from(peers.values());
+}
+function getDiscoveredPeer(peerInstanceId) {
+  return peers.get(peerInstanceId);
+}
+function onPeerDiscovered(cb) {
+  listeners.discovered.add(cb);
+  return () => {
+    listeners.discovered.delete(cb);
+  };
+}
+function onPeerLost(cb) {
+  listeners.lost.add(cb);
+  return () => {
+    listeners.lost.delete(cb);
+  };
+}
+function isMdnsRunning() {
+  return bonjourInstance !== null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDiscoveredPeer,
+  getDiscoveredPeers,
+  getInstanceId,
+  isMdnsRunning,
+  onPeerDiscovered,
+  onPeerLost,
+  startMdns,
+  stopMdns,
+  updateAdvertisedName
+});

package/src/backend/services/mobile-api-server.js

@@ -0,0 +1,281 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mobile_api_server_exports = {};
+__export(mobile_api_server_exports, {
+  getMobileApiPort: () => getMobileApiPort,
+  isMobileApiRunning: () => isMobileApiRunning,
+  resetMobileApiRateLimit: () => resetMobileApiRateLimit,
+  startMobileApiServer: () => startMobileApiServer,
+  stopMobileApiServer: () => stopMobileApiServer
+});
+module.exports = __toCommonJS(mobile_api_server_exports);
+var import_node_http = __toESM(require("node:http"));
+var import_settings_service = require("./settings-service");
+var import_peer_connection_service = require("./peer-connection-service");
+const MAX_BODY_BYTES = 256 * 1024;
+const SOCKET_TIMEOUT_MS = 15e3;
+const RATE_WINDOW_MS = 6e4;
+const RATE_MAX_REQUESTS = 60;
+const RATE_MAX_SOURCES = 1024;
+let server = null;
+let boundPort = 0;
+async function startMobileApiServer() {
+  if (server) {
+    return boundPort;
+  }
+  const settings = (0, import_settings_service.getSettings)();
+  const requestedPort = settings.device.mobileApiPort || 19480;
+  return new Promise((resolve, reject) => {
+    const tryPort = (candidate, attemptsLeft) => {
+      const srv = import_node_http.default.createServer(handleRequest);
+      srv.on("error", (err) => {
+        if (err.code === "EADDRINUSE" && attemptsLeft > 0) {
+          console.log(`[MobileAPI] Port ${candidate} in use, trying ${candidate + 1}\u2026`);
+          tryPort(candidate + 1, attemptsLeft - 1);
+        } else {
+          reject(err);
+        }
+      });
+      srv.setTimeout(SOCKET_TIMEOUT_MS, (socket) => socket.destroy());
+      srv.headersTimeout = SOCKET_TIMEOUT_MS;
+      srv.requestTimeout = SOCKET_TIMEOUT_MS;
+      srv.listen(candidate, "0.0.0.0", () => {
+        server = srv;
+        boundPort = candidate;
+        console.log(`[MobileAPI] Listening on 0.0.0.0:${candidate}`);
+        resolve(candidate);
+      });
+    };
+    tryPort(requestedPort, 10);
+  });
+}
+function stopMobileApiServer() {
+  if (server) {
+    try {
+      server.closeAllConnections?.();
+      server.close();
+    } catch {
+    }
+    server = null;
+    boundPort = 0;
+    hits.clear();
+    console.log("[MobileAPI] Stopped");
+  }
+}
+function getMobileApiPort() {
+  return boundPort;
+}
+function isMobileApiRunning() {
+  return server !== null;
+}
+function handleRequest(req, res) {
+  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 (rateLimited(req)) {
+    sendJson(res, 429, { error: "Too many requests" });
+    return;
+  }
+  const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+  if (req.method === "POST" && url.pathname === "/api/mobile/auth/challenge") {
+    handleChallenge(req, res);
+    return;
+  }
+  if (req.method === "POST" && url.pathname === "/api/mobile/reconnect") {
+    handleReconnect(req, res);
+    return;
+  }
+  if (req.method === "POST" && url.pathname === "/api/mobile/reconnect/answer") {
+    handleReconnectAnswer(req, res);
+    return;
+  }
+  if (req.method === "GET" && url.pathname === "/api/mobile/status") {
+    handleStatus(res);
+    return;
+  }
+  res.writeHead(404, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ error: "Not found" }));
+}
+function handleChallenge(req, res) {
+  readJsonBody(req).then((data) => {
+    const pairingId = typeof data.pairingId === "string" ? data.pairingId : "";
+    if (!pairingId) {
+      sendJson(res, 400, { error: "Missing pairingId" });
+      return;
+    }
+    sendJson(res, 200, (0, import_peer_connection_service.issueReconnectChallenge)(pairingId));
+  }).catch((err) => failBody(res, err));
+}
+function handleReconnect(req, res) {
+  readJsonBody(req).then(async (data) => {
+    const pairingId = typeof data.pairingId === "string" ? data.pairingId : "";
+    const nonce = typeof data.nonce === "string" ? data.nonce : "";
+    const mac = typeof data.mac === "string" ? data.mac : "";
+    const expiresAt = typeof data.expiresAt === "number" ? data.expiresAt : 0;
+    if (!pairingId || !nonce || !mac || !expiresAt) {
+      sendJson(res, 400, { error: "Missing pairingId or challenge response" });
+      return;
+    }
+    const result = await (0, import_peer_connection_service.startReconnection)(pairingId, { nonce, expiresAt, mac });
+    if (!result) {
+      sendJson(res, 403, { error: "Reconnection refused" });
+      return;
+    }
+    sendJson(res, 200, {
+      offer: result.offer,
+      ice: result.iceCandidates,
+      fingerprint: result.fingerprint,
+      pairingId: result.pairingId,
+      // Consumed with the answer, so a captured proof is worth one use.
+      answerNonce: result.answerNonce,
+      // Lets the phone verify it is talking to the desktop it paired with,
+      // without depending on a certificate that changes every restart.
+      offerMac: result.offerMac
+    });
+  }).catch((err) => failBody(res, err));
+}
+function handleReconnectAnswer(req, res) {
+  readJsonBody(req).then(async (data) => {
+    const pairingId = typeof data.pairingId === "string" ? data.pairingId : "";
+    const answer = typeof data.answer === "string" ? data.answer : "";
+    const fingerprint = typeof data.fingerprint === "string" ? data.fingerprint : "";
+    const ice = Array.isArray(data.ice) ? data.ice : [];
+    const mac = typeof data.mac === "string" ? data.mac : "";
+    if (!pairingId || !answer) {
+      sendJson(res, 400, { error: "Missing pairingId or answer" });
+      return;
+    }
+    const success = await (0, import_peer_connection_service.completeReconnection)(pairingId, answer, ice, fingerprint, mac);
+    if (!success) {
+      sendJson(res, 403, { error: "Reconnection refused" });
+      return;
+    }
+    sendJson(res, 200, { connected: true });
+  }).catch((err) => failBody(res, err));
+}
+function handleStatus(res) {
+  try {
+    const status = (0, import_peer_connection_service.getPeerManagerStatus)();
+    const settings = (0, import_settings_service.getSettings)();
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({
+      ok: true,
+      deviceName: settings.device.deviceName || require("node:os").hostname(),
+      port: boundPort,
+      ...status
+    }));
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: String(err) }));
+  }
+}
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    let size = 0;
+    req.on("data", (chunk) => {
+      size += Buffer.byteLength(chunk);
+      if (size > MAX_BODY_BYTES) {
+        reject(new BodyTooLarge());
+        req.destroy();
+        return;
+      }
+      body += chunk;
+    });
+    req.on("end", () => {
+      try {
+        const parsed = JSON.parse(body || "{}");
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+          reject(new BadJson());
+          return;
+        }
+        resolve(parsed);
+      } catch {
+        reject(new BadJson());
+      }
+    });
+    req.on("error", reject);
+  });
+}
+class BodyTooLarge extends Error {
+  status = 413;
+}
+class BadJson extends Error {
+  status = 400;
+}
+function sendJson(res, status, payload) {
+  if (res.headersSent) return;
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(payload));
+}
+function failBody(res, err) {
+  if (err instanceof BodyTooLarge) return sendJson(res, 413, { error: "Request body too large" });
+  if (err instanceof BadJson) return sendJson(res, 400, { error: "Invalid JSON" });
+  console.warn("[MobileAPI] Request failed:", err);
+  sendJson(res, 500, { error: "Request failed" });
+}
+const hits = /* @__PURE__ */ new Map();
+function rateLimited(req, now = Date.now()) {
+  const source = req.socket.remoteAddress ?? "unknown";
+  const entry = hits.get(source);
+  if (!entry || entry.resetAt <= now) {
+    if (hits.size >= RATE_MAX_SOURCES) {
+      for (const [key, value] of hits) if (value.resetAt <= now) hits.delete(key);
+      if (hits.size >= RATE_MAX_SOURCES) {
+        const oldest = hits.keys().next();
+        if (!oldest.done) hits.delete(oldest.value);
+      }
+    }
+    hits.set(source, { count: 1, resetAt: now + RATE_WINDOW_MS });
+    return false;
+  }
+  entry.count += 1;
+  if (entry.count > RATE_MAX_REQUESTS) {
+    if (entry.count === RATE_MAX_REQUESTS + 1) {
+      console.warn(`[MobileAPI] Rate limiting ${source} \u2014 ${entry.count} requests in the window`);
+    }
+    return true;
+  }
+  return false;
+}
+function resetMobileApiRateLimit() {
+  hits.clear();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getMobileApiPort,
+  isMobileApiRunning,
+  resetMobileApiRateLimit,
+  startMobileApiServer,
+  stopMobileApiServer
+});