@sksoftofficial/ocduet 0.2.1

package/src/qrterm.js

@@ -0,0 +1,5 @@
+import { renderUnicodeCompact } from "./qrcodegen.js";
+
+export function qrText(url) {
+  return renderUnicodeCompact(url, { border: 2, ecc: "L" });
+}

package/src/relay-client.js

@@ -0,0 +1,172 @@
+// ocduet relay client — the desktop half of the relayer tunnel.
+// Runs inside the daemon process. Keeps one persistent outbound connection
+// to the relayer (`ocduet relay link <url> <secret>` writes the identity),
+// replays relayed http requests against the daemon's own loopback server and
+// splices relayed phone websockets onto the loopback upgrade path — so the
+// existing E2EE phone protocol runs end-to-end, phone to daemon, with the
+// relayer only ever seeing ciphertext.
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { WebSocket } from "ws";
+import { dataDir } from "./paths.js";
+
+const REG_MSG = (desktopId, pubB64, ts) => `ocduet-relay-reg|${desktopId}|${pubB64}|${ts}`;
+const HTTP_RESP_LIMIT = 10 * 1024 * 1024;
+const BACKOFF_MIN_MS = 3_000;
+const BACKOFF_MAX_MS = 60_000;
+
+export function relayConfigPath() {
+  return path.join(dataDir(), "relay.json");
+}
+
+export function readRelayConfig() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(relayConfigPath(), "utf8"));
+    if (raw?.url && raw?.desktopId && raw?.priv && raw?.pub) return raw;
+  } catch {}
+  return null;
+}
+
+// cert pinning for self-signed relayers: the exact cert PEM is captured at
+// `relay link` time and trusted as its own CA on every connection. Mutual
+// auth still comes from the ed25519 register signature — the pin kills
+// silent MITM even without a domain.
+export function relayTlsOpts(cfg) {
+  return cfg?.certPem ? { ca: cfg.certPem } : { rejectUnauthorized: false };
+}
+
+const state = { linked: false, connected: false, url: null, desktopId: null, since: null, lastError: null, reconnects: 0 };
+let stopped = false;
+
+export function relayStatus() {
+  return { ...state };
+}
+
+export function stopRelayClient() {
+  stopped = true;
+}
+
+export function startRelayClient({ localPort }) {
+  const cfg = readRelayConfig();
+  if (!cfg) return null;
+  const priv = crypto.createPrivateKey({ key: Buffer.from(cfg.priv, "base64"), format: "der", type: "pkcs8" });
+  const pubB64 = cfg.pub;
+  const sign = (msg) => crypto.sign(null, Buffer.from(msg, "utf8"), priv).toString("base64");
+  const wsUrl = new URL("/desktop", cfg.url);
+  wsUrl.protocol = wsUrl.protocol === "http:" ? "ws:" : "wss:";
+  const tlsOpts = relayTlsOpts(cfg);
+
+  state.linked = true;
+  state.url = cfg.url;
+  state.desktopId = cfg.desktopId;
+
+  let ws = null;            // control channel to the relayer
+  const conns = new Map();  // cid -> loopback ws into our own phone handler
+
+  const send = (obj) => {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      try { ws.send(JSON.stringify(obj)); } catch {}
+    }
+  };
+
+  // replay a relayed http request against our own loopback plain-http server.
+  // The marker header lets the daemon serve relayed callers a reduced /status
+  // (they came in through the public relayer — not trusted for local detail).
+  async function handleHttpReq(msg) {
+    let out;
+    try {
+      const res = await fetch(`http://127.0.0.1:${localPort}${msg.path}`, {
+        method: msg.method,
+        headers: { ...(msg.headers || {}), "x-ocduet-via-relay": "1" },
+        body: msg.body ? Buffer.from(msg.body, "base64") : undefined,
+        signal: AbortSignal.timeout(25_000),
+      });
+      const headers = {};
+      res.headers.forEach((v, k) => { headers[k] = v; });
+      const body = Buffer.from(await res.arrayBuffer());
+      if (body.length > HTTP_RESP_LIMIT) throw new Error("response too large");
+      out = { t: "httpResp", rid: msg.rid, status: res.status, headers, body: body.toString("base64") };
+    } catch (err) {
+      out = { t: "httpResp", rid: msg.rid, status: 502, headers: { "content-type": "text/plain" }, body: Buffer.from(String(err?.message || err)).toString("base64") };
+    }
+    send(out);
+  }
+
+  // splice a relayed phone websocket onto our own upgrade path: e2ee=1 marks
+  // it as a phone connection exactly like a direct LAN phone socket
+  function openConn(msg) {
+    const url = new URL(msg.path || "/", "http://x");
+    if (url.searchParams.get("e2ee") !== "1") url.searchParams.set("e2ee", "1");
+    const loop = new WebSocket(`ws://127.0.0.1:${localPort}${url.pathname}${url.search}`);
+    conns.set(msg.cid, loop);
+    loop.on("message", (data, isBinary) => {
+      if (!isBinary) send({ t: "data", cid: msg.cid, d: data.toString() });
+    });
+    loop.on("close", (code, reason) => {
+      conns.delete(msg.cid);
+      send({ t: "close", cid: msg.cid, code, reason: reason?.toString() || undefined });
+    });
+    loop.on("error", () => { try { loop.terminate(); } catch {} });
+  }
+
+  let backoff = BACKOFF_MIN_MS;
+  let dialTimer = null;
+
+  function dial() {
+    if (stopped) return;
+    ws = new WebSocket(wsUrl, { ...tlsOpts, handshakeTimeout: 10_000 });
+    ws.on("open", () => {
+      state.connected = true;
+      state.since = Date.now();
+      state.lastError = null;
+      const ts = Date.now();
+      ws.send(JSON.stringify({ t: "register", desktopId: cfg.desktopId, pub: pubB64, ts, sig: sign(REG_MSG(cfg.desktopId, pubB64, ts)) }));
+      backoff = BACKOFF_MIN_MS;
+    });
+    ws.on("message", (raw) => {
+      let msg;
+      try { msg = JSON.parse(raw.toString()); } catch { return; }
+      if (msg.t === "registered") return; // tunnel confirmed by the relayer
+      if (msg.t === "httpReq") handleHttpReq(msg).catch(() => {});
+      else if (msg.t === "open") openConn(msg);
+      else if (msg.t === "data") { const c = conns.get(msg.cid); if (c) { try { c.send(msg.d); } catch {} } }
+      else if (msg.t === "close") {
+        const c = conns.get(msg.cid);
+        if (c) { try { c.close(msg.code || 1000); } catch { try { c.terminate(); } catch {} } }
+      }
+    });
+    ws.on("close", (code, reason) => {
+      for (const c of conns.values()) { try { c.terminate(); } catch {} }
+      conns.clear();
+      if (!stopped) {
+        state.connected = false;
+        state.reconnects++;
+        state.lastError = reason?.toString() || `closed ${code}`;
+        dialTimer = setTimeout(dial, backoff + Math.floor(Math.random() * 1000));
+        backoff = Math.min(backoff * 2, BACKOFF_MAX_MS);
+      }
+    });
+    ws.on("error", () => {}); // surfaced via close
+    ws.on("pong", () => { ws.alive = true; });
+  }
+  dial();
+
+  const ping = setInterval(() => {
+    if (stopped) { clearInterval(ping); return; }
+    if (!ws || ws.readyState > WebSocket.OPEN) return;
+    if (ws.alive === false) { try { ws.terminate(); } catch {} return; }
+    ws.alive = false;
+    try { ws.ping(); } catch {}
+  }, 30_000);
+
+  return {
+    status: relayStatus,
+    stop() {
+      stopped = true;
+      clearTimeout(dialTimer);
+      clearInterval(ping);
+      try { ws && ws.close(); } catch {}
+    },
+  };
+}

package/src/relayer.js

@@ -0,0 +1,337 @@
+// ocduet relayer — a public ciphertext pipe for the ocduet daemon.
+// Runs on any VPS (`ocduet relayer serve`). It terminates TLS and nothing
+// else: every http request and every websocket frame is relayed through a
+// persistent outbound tunnel to a linked desktop daemon, which serves the
+// web app, the pairing endpoints and the E2EE phone protocol. The relayer
+// holds no pairing keys and never sees plaintext protocol frames.
+//
+// Trust model: desktops authenticate with an ed25519 keypair generated at
+// `ocduet relay link` time. First enrollment additionally requires the
+// relayer's enroll secret (printed at first start / `ocduet relayer secret`)
+// so strangers cannot register on your relay. Phones reach a desktop by
+// id — `?d=<desktopId>` sets the ocduet_d routing cookie.
+import https from "node:https";
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { WebSocketServer } from "ws";
+import { verifySig } from "./e2ee.js";
+
+const VERSION = "0.1.0";
+const REG_MSG = (desktopId, pubB64, ts) => `ocduet-relay-reg|${desktopId}|${pubB64}|${ts}`;
+const HTTP_TIMEOUT_MS = 30_000;
+const HTTP_REQ_LIMIT = 2 * 1024 * 1024;  // phone -> desktop request bodies
+const HTTP_RESP_LIMIT = 10 * 1024 * 1024; // desktop -> phone responses (assets)
+
+export function relayerDir() {
+  const override = process.env.OCDUET_RELAYER_DIR;
+  if (override && path.isAbsolute(override)) return override;
+  const xdg = process.env.XDG_DATA_HOME;
+  const base = xdg && path.isAbsolute(xdg) ? xdg : path.join(os.homedir(), ".local", "share");
+  return path.join(base, "ocduet-relayer");
+}
+
+function storePath() { return path.join(relayerDir(), "store.json"); }
+function logPath() { return path.join(relayerDir(), "relayer.log"); }
+
+function log(...args) {
+  try {
+    fs.appendFileSync(logPath(), `${new Date().toISOString()} ${args.join(" ")}\n`, { mode: 0o600 });
+  } catch {}
+}
+
+function loadStore() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(storePath(), "utf8"));
+    if (raw?.secret && typeof raw.enrolled === "object") return raw;
+  } catch {}
+  const store = { secret: crypto.randomBytes(24).toString("base64url"), enrolled: {} };
+  fs.mkdirSync(relayerDir(), { recursive: true });
+  fs.writeFileSync(storePath(), JSON.stringify(store, null, 2) + "\n", { mode: 0o600 });
+  try { fs.chmodSync(storePath(), 0o600); } catch {}
+  log("generated enroll secret");
+  return store;
+}
+
+function saveStore(store) {
+  fs.mkdirSync(relayerDir(), { recursive: true });
+  const tmp = storePath() + `.${process.pid}.tmp`;
+  // the store holds the enroll secret — keep it 0600 across rewrites too,
+  // not just at first creation (a plain writeFileSync defaults to 0644)
+  fs.writeFileSync(tmp, JSON.stringify(store, null, 2) + "\n", { mode: 0o600 });
+  try { fs.chmodSync(tmp, 0o600); } catch {}
+  fs.renameSync(tmp, storePath());
+}
+
+function sha256hex(s) { return crypto.createHash("sha256").update(s).digest("hex"); }
+
+function ensureCert() {
+  const certP = path.join(relayerDir(), "cert.pem");
+  const keyP = path.join(relayerDir(), "cert.key.pem");
+  if (fs.existsSync(certP) && fs.existsSync(keyP)) {
+    return { cert: fs.readFileSync(certP), key: fs.readFileSync(keyP) };
+  }
+  fs.mkdirSync(relayerDir(), { recursive: true });
+  const out = spawnSync("openssl", [
+    "req", "-x509", "-newkey", "ec", "-pkeyopt", "ec_paramgen_curve:prime256v1",
+    "-keyout", keyP, "-out", certP, "-days", "3650", "-nodes",
+    "-subj", "/CN=ocduet-relayer",
+    "-addext", "subjectAltName=DNS:localhost,IP:127.0.0.1",
+  ], { stdio: "ignore" });
+  if (out.status !== 0) throw new Error("openssl cert generation failed — is openssl installed?");
+  try { fs.chmodSync(keyP, 0o600); } catch {}
+  log("generated tls cert");
+  return { cert: fs.readFileSync(certP), key: fs.readFileSync(keyP) };
+}
+
+// ---------- tunnels ----------
+const tunnels = new Map(); // desktopId -> { ws, since, httpPending: Map<rid,res>, conns: Map<cid, ws> }
+
+function routeId(req) {
+  const url = new URL(req.url || "/", "http://x");
+  const d = url.searchParams.get("d");
+  if (d && /^[a-f0-9]{6,32}$/.test(d)) return { id: d, setCookie: true };
+  const m = /(?:^|;\s*)ocduet_d=([a-f0-9]{6,32})(?:;|$)/.exec(req.headers.cookie || "");
+  if (m) return { id: m[1], setCookie: false };
+  return null;
+}
+
+function offlinePage(host) {
+  return `<!doctype html><meta name="viewport" content="width=device-width,initial-scale=1"><body style="font-family:system-ui;background:#151716;color:#e8ece9;display:flex;align-items:center;justify-content:center;height:100vh;margin:0"><div style="text-align:center"><div style="font-size:44px">⏸</div><h2 style="font-weight:600">Desktop offline</h2><p style="color:#9aa3a0">The ocduet desktop this link points at is not connected to the relayer.<br/>Start opencode on your desktop and try again.</p></div></body>`;
+}
+
+function readBody(req, limit) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on("data", (c) => {
+      size += c.length;
+      if (size > limit) { reject(new Error("body too large")); req.destroy(); return; }
+      chunks.push(c);
+    });
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+
+async function relayHttp(req, res) {
+  const route = routeId(req);
+  if (!route) {
+    res.writeHead(404, { "content-type": "text/plain" });
+    res.end("ocduet relayer — no desktop id. Use the link or QR from `ocduet qr`.");
+    return;
+  }
+  const tunnel = tunnels.get(route.id);
+  const headers = {};
+  if (route.setCookie) {
+    headers["set-cookie"] = `ocduet_d=${route.id}; Path=/; Max-Age=31536000; SameSite=Lax${req.socket.encrypted ? "; Secure" : ""}`;
+  }
+  if (!tunnel) {
+    res.writeHead(503, { "content-type": "text/html; charset=utf-8", ...headers });
+    res.end(offlinePage());
+    return;
+  }
+  const rid = crypto.randomUUID();
+  const fwdHeaders = {};
+  for (const [k, v] of Object.entries(req.headers)) {
+    if (["host", "connection", "cookie", "content-length", "transfer-encoding", "accept-encoding"].includes(k)) continue;
+    fwdHeaders[k] = v;
+  }
+  let bodyB64 = "";
+  if (req.method !== "GET" && req.method !== "HEAD") {
+    try { bodyB64 = (await readBody(req, HTTP_REQ_LIMIT)).toString("base64"); }
+    catch { res.writeHead(413, { "content-type": "text/plain", ...headers }); res.end("body too large"); return; }
+  }
+  const settle = (status, h, body) => {
+    if (tunnel.httpPending.delete(rid)) {
+      res.writeHead(status, { ...h, ...headers });
+      res.end(body);
+    }
+  };
+  tunnel.httpPending.set(rid, settle);
+  const timer = setTimeout(() => settle(504, { "content-type": "text/plain" }, "desktop timeout"), HTTP_TIMEOUT_MS);
+  tunnel.httpPending.get(rid).timer = timer;
+  try {
+    tunnel.ws.send(JSON.stringify({ t: "httpReq", rid, method: req.method, path: req.url, headers: fwdHeaders, body: bodyB64 }));
+  } catch {
+    clearTimeout(timer);
+    settle(503, { "content-type": "text/html; charset=utf-8" }, offlinePage());
+  }
+}
+
+function handleDesktopFrame(desktopId, raw) {
+  const tunnel = tunnels.get(desktopId);
+  if (!tunnel) return;
+  let msg;
+  try { msg = JSON.parse(raw.toString()); } catch { return; }
+  if (msg.t === "httpResp" && tunnel.httpPending.has(msg.rid)) {
+    const settle = tunnel.httpPending.get(msg.rid);
+    clearTimeout(settle.timer);
+    const body = msg.body ? Buffer.from(msg.body, "base64") : "";
+    if (body.length > HTTP_RESP_LIMIT) return settle(502, { "content-type": "text/plain" }, "response too large");
+    const h = {};
+    for (const [k, v] of Object.entries(msg.headers || {})) {
+      if (["connection", "transfer-encoding", "content-encoding", "content-length", "keep-alive"].includes(k)) continue;
+      h[k] = v;
+    }
+    settle(msg.status || 200, h, body);
+  } else if (msg.t === "data" && tunnel.conns.has(msg.cid)) {
+    try { tunnel.conns.get(msg.cid).send(msg.d); } catch {}
+  } else if (msg.t === "close" && tunnel.conns.has(msg.cid)) {
+    const phoneWs = tunnel.conns.get(msg.cid);
+    tunnel.conns.delete(msg.cid);
+    try { phoneWs.close(msg.code || 1000, msg.reason || "desktop closed"); } catch { try { phoneWs.terminate(); } catch {} }
+  }
+}
+
+function dropTunnel(desktopId, why) {
+  const tunnel = tunnels.get(desktopId);
+  if (!tunnel) return;
+  tunnels.delete(desktopId);
+  log("tunnel down:", desktopId, why || "");
+  for (const settle of tunnel.httpPending.values()) {
+    clearTimeout(settle.timer);
+    try { settle(503, { "content-type": "text/html; charset=utf-8" }, offlinePage()); } catch {}
+  }
+  for (const ws of tunnel.conns.values()) {
+    try { ws.close(1013, "desktop tunnel lost"); } catch { try { ws.terminate(); } catch {} }
+  }
+}
+
+// ---------- server ----------
+export function serve(argv = []) {
+  const port = parseInt(argv.find((a, i) => argv[i - 1] === "--port") || process.env.OCDUET_RELAYER_PORT || "4290", 10);
+  const certIdx = argv.indexOf("--cert");
+  const keyIdx = argv.indexOf("--key");
+  const store = loadStore();
+  try { fs.chmodSync(logPath(), 0o600); } catch {} // tighten logs from older versions
+  const tls = (certIdx !== -1 && keyIdx !== -1 && argv[certIdx + 1] && argv[keyIdx + 1])
+    ? { cert: fs.readFileSync(argv[certIdx + 1]), key: fs.readFileSync(argv[keyIdx + 1]) }
+    : ensureCert();
+
+  const wss = new WebSocketServer({ noServer: true });
+
+  const onRequest = (req, res) => {
+    const url = new URL(req.url, "http://x");
+    if (url.pathname === "/status") {
+      // deliberately bare: desktop ids are the only routing secret this
+      // service knows — listing live tunnels would hand them to anyone
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({ app: "ocduet-relayer", relayer: true, ok: true, version: VERSION, port }));
+      return;
+    }
+    relayHttp(req, res).catch(() => {
+      try { res.writeHead(502); res.end("relay error"); } catch {}
+    });
+  };
+
+  const onUpgrade = (req, socket, head) => {
+    const url = new URL(req.url, "http://x");
+    if (url.pathname === "/desktop") {
+      wss.handleUpgrade(req, socket, head, (ws) => attachDesktop(ws));
+      return;
+    }
+    const route = routeId(req);
+    if (!route) {
+      socket.write("HTTP/1.1 404 Not Found\r\n\r\n");
+      socket.destroy();
+      return;
+    }
+    const tunnel = tunnels.get(route.id);
+    if (!tunnel) {
+      socket.write("HTTP/1.1 503 Service Unavailable\r\n\r\ndesktop offline");
+      socket.destroy();
+      return;
+    }
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      const cid = crypto.randomUUID();
+      tunnel.conns.set(cid, ws);
+      ws.on("message", (data, isBinary) => {
+        if (isBinary) { try { ws.close(1003, "binary not supported"); } catch {} return; }
+        try { tunnel.ws.send(JSON.stringify({ t: "data", cid, d: data.toString() })); } catch {}
+      });
+      ws.on("close", (code) => {
+        if (tunnel.conns.get(cid) === ws) {
+          tunnel.conns.delete(cid);
+          try { tunnel.ws.send(JSON.stringify({ t: "close", cid, code })); } catch {}
+        }
+      });
+      ws.on("error", () => {});
+      try {
+        tunnel.ws.send(JSON.stringify({ t: "open", cid, path: req.url, headers: { "user-agent": req.headers["user-agent"] || "" } }));
+      } catch {
+        try { ws.close(1013, "tunnel lost"); } catch {}
+      }
+    });
+  };
+
+  function attachDesktop(ws) {
+    let registeredId = null;
+    let settled = false;
+    const regTimer = setTimeout(() => { if (!settled) { try { ws.close(4001, "register timeout"); } catch {} } }, 10_000);
+    ws.on("message", (raw) => {
+      let msg;
+      try { msg = JSON.parse(raw.toString()); } catch { return; }
+      if (!registeredId) {
+        if (msg?.t !== "register") { try { ws.close(4001, "expected register"); } catch {} return; }
+        const { desktopId, pub, ts, sig, secret } = msg;
+        if (!/^[a-f0-9]{6,32}$/.test(String(desktopId || ""))) { try { ws.close(4001, "bad id"); } catch {} return; }
+        if (Math.abs(Date.now() - Number(ts)) > 120_000) { try { ws.close(4001, "stale register"); } catch {} return; }
+        const pubBuf = Buffer.from(String(pub || ""), "base64");
+        if (pubBuf.length !== 32) { try { ws.close(4001, "bad pub"); } catch {} return; }
+        if (!verifySig(pubBuf, REG_MSG(desktopId, pub, ts), sig)) { try { ws.close(4003, "bad signature"); } catch {} return; }
+        const enrolledPub = store.enrolled[desktopId]?.pub;
+        let enrolled = false;
+        if (enrolledPub === String(pub)) enrolled = true;
+        else if (sha256hex(String(secret || "")) === sha256hex(store.secret)) {
+          store.enrolled[desktopId] = { pub: String(pub), addedAt: Date.now() };
+          saveStore(store);
+          enrolled = true;
+          log("enrolled desktop:", desktopId);
+        }
+        if (!enrolled) { try { ws.close(4003, "unknown desktop — link with the enroll secret"); } catch {} return; }
+        registeredId = desktopId;
+        settled = true;
+        clearTimeout(regTimer);
+        dropTunnel(desktopId, "replaced by new connection");
+        tunnels.set(desktopId, { id: desktopId, ws, since: Date.now(), httpPending: new Map(), conns: new Map() });
+        ws.send(JSON.stringify({ t: "registered", ok: true, desktopId }));
+        log("tunnel up:", desktopId);
+        return;
+      }
+      handleDesktopFrame(registeredId, raw);
+    });
+    ws.on("close", () => { clearTimeout(regTimer); if (registeredId) dropTunnel(registeredId, "closed"); });
+    ws.on("error", () => {});
+    ws.alive = true;
+    ws.on("pong", () => { ws.alive = true; });
+    const ping = setInterval(() => {
+      if (!ws.alive) { try { ws.terminate(); } catch {}; clearInterval(ping); return; }
+      ws.alive = false;
+      try { ws.ping(); } catch {}
+    }, 30_000);
+    ws.on("close", () => clearInterval(ping));
+  }
+
+  const server = https.createServer({ key: tls.key, cert: tls.cert }, onRequest);
+  server.on("upgrade", onUpgrade);
+  server.listen(port, "0.0.0.0", () => {
+    console.log(`ocduet relayer v${VERSION} listening on https://0.0.0.0:${port}`);
+    console.log(`data dir: ${relayerDir()}`);
+    console.log(`enroll secret: ${store.secret}`);
+    console.log(`  (also printable later: ocduet relayer secret)`);
+    console.log(`desktops link with:  ocduet relay link https://<this-host>:${port} ${store.secret}`);
+  });
+  const cleanup = () => { try { server.close(); } catch {} process.exit(0); };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+  return server;
+}
+
+export function printSecret() {
+  const store = loadStore();
+  console.log(store.secret);
+}