@wipcomputer/wip-ldm-os 0.4.85-alpha.9 → 0.4.87-alpha.1

package/src/hosted-mcp/app/pair.html

@@ -74,7 +74,7 @@
     <!-- View 3: success -->
     <div id="success-view" style="display: none;">
       <h1>Paired.</h1>
-      <div class="sub">Your laptop will pick this up in a few seconds.</div>
+      <div id="success-sub" class="sub">Your laptop will pick this up in a few seconds.</div>
       <div class="footer">You can close this tab.</div>
     </div>
   </div>
@@ -86,6 +86,7 @@ var PAIR_CODE_REGEX = /^[ABCDEFGHJKLMNPQRSTUVWXYZ23456789]{6}$/;
 
 function getApiKey() { return sessionStorage.getItem('wip_api_key'); }
 function getHandle() { return sessionStorage.getItem('wip_handle') || '(unknown)'; }
+function getPairPresenceToken() { return sessionStorage.getItem('wip_codex_pair_presence_token'); }
 
 function setStatus(elId, msg, kind) {
   var el = document.getElementById(elId);
@@ -104,7 +105,9 @@ function readCodeFromPath() {
 }
 
 // POST the code to /api/codex-relay/pair-complete using the api_key
-// from sessionStorage as Bearer token. On success, show the success view.
+// from sessionStorage as Bearer token. Daemon key pairing also sends the
+// short-lived token minted by the passkey verify step, so a stale ck- token
+// alone cannot replace a daemon. On success, show the success view.
 async function submitPair(code, statusElId) {
   if (!PAIR_CODE_REGEX.test(code)) {
     setStatus(statusElId, 'That does not look like a valid code.', 'error');
@@ -118,7 +121,10 @@ async function submitPair(code, statusElId) {
         'Content-Type': 'application/json',
         'Authorization': 'Bearer ' + getApiKey(),
       },
-      body: JSON.stringify({ code: code }),
+      body: JSON.stringify({
+        code: code,
+        codex_pair_presence_token: getPairPresenceToken(),
+      }),
     });
     var data = await res.json();
     if (!res.ok) {
@@ -127,9 +133,21 @@ async function submitPair(code, statusElId) {
       if (res.status === 410 || res.status === 404) {
         msg += ' Run codex-daemon link again on your laptop to get a fresh code.';
       }
+      if (res.status === 403 && data && data.error === 'fresh_presence_required') {
+        msg = 'Sign in again with your passkey to relink this daemon.';
+        sessionStorage.removeItem('wip_api_key');
+        sessionStorage.removeItem('wip_codex_pair_presence_token');
+        setTimeout(function() {
+          location.replace('/login?next=' + encodeURIComponent('/pair/' + code));
+        }, 1200);
+      }
       setStatus(statusElId, msg, 'error');
       return false;
     }
+    sessionStorage.removeItem('wip_codex_pair_presence_token');
+    document.getElementById('success-sub').textContent = data.replaced_daemon_key
+      ? 'Remote Control relinked this laptop. Existing browser control tabs need to reconnect.'
+      : 'Your laptop will pick this up in a few seconds.';
     document.getElementById('confirm-view').style.display = 'none';
     document.getElementById('manual-view').style.display = 'none';
     document.getElementById('success-view').style.display = 'block';

package/src/hosted-mcp/codex-relay-e2ee-registry.mjs

@@ -0,0 +1,208 @@
+import { createHash, randomUUID } from "node:crypto";
+
+export function normalizeCodexCryptoVersions(versions) {
+  const out = Array.isArray(versions)
+    ? versions.filter((v) => typeof v === "string" && v.length > 0 && v.length <= 32).slice(0, 8)
+    : [];
+  return out.length ? out : ["e2ee-v1"];
+}
+
+export function codexDaemonPubkeyFingerprint(pubkey) {
+  if (typeof pubkey !== "string" || !pubkey) return null;
+  return "sha256:" + createHash("sha256").update(pubkey).digest("base64url").slice(0, 16);
+}
+
+export function evaluateCodexDaemonReconnectPubkey(existingKey, incomingPubkey) {
+  const existingPubkey = typeof existingKey?.pubkey === "string" && existingKey.pubkey ? existingKey.pubkey : null;
+  const nextPubkey = typeof incomingPubkey === "string" && incomingPubkey && incomingPubkey.length <= 1024 ? incomingPubkey : null;
+  const oldFingerprint = codexDaemonPubkeyFingerprint(existingPubkey);
+  const newFingerprint = codexDaemonPubkeyFingerprint(nextPubkey);
+
+  if (!nextPubkey) {
+    return {
+      allowed: false,
+      reason: "invalid_daemon_pubkey",
+      replaced: false,
+      old_fingerprint: oldFingerprint,
+      new_fingerprint: newFingerprint,
+    };
+  }
+  if (!existingPubkey || existingPubkey === nextPubkey) {
+    return {
+      allowed: true,
+      reason: null,
+      replaced: false,
+      old_fingerprint: oldFingerprint,
+      new_fingerprint: newFingerprint,
+    };
+  }
+  return {
+    allowed: false,
+    reason: "fresh_pair_required",
+    replaced: true,
+    old_fingerprint: oldFingerprint,
+    new_fingerprint: newFingerprint,
+  };
+}
+
+export function buildCodexBootstrapPayload({ identity, threadId, daemonOnline, daemonKey }) {
+  return {
+    handle: identity.handle,
+    thread_id: threadId,
+    daemon_online: daemonOnline,
+    daemon_public_key: daemonKey ? daemonKey.pubkey : null,
+    daemon_crypto_versions: daemonKey ? daemonKey.crypto_versions : null,
+    supported_crypto_versions: ["e2ee-v1"],
+    e2ee_available: !!daemonKey,
+  };
+}
+
+export function createCodexDaemonPubkeyRegistry({
+  usePrisma,
+  prisma,
+  devMode = false,
+  logger = console,
+} = {}) {
+  const pubkeys = new Map();
+  const auditLog = [];
+
+  async function ensureStore() {
+    if (!usePrisma) return;
+    await prisma.$executeRawUnsafe(`
+      CREATE TABLE IF NOT EXISTS codex_daemon_e2ee_keys (
+        tenant_id TEXT PRIMARY KEY,
+        pubkey TEXT NOT NULL,
+        crypto_versions_json TEXT NOT NULL,
+        registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
+      )
+    `);
+  }
+
+  async function ensureAuditStore() {
+    if (!usePrisma) return;
+    await prisma.$executeRawUnsafe(`
+      CREATE TABLE IF NOT EXISTS codex_daemon_e2ee_key_audit (
+        id TEXT PRIMARY KEY,
+        tenant_id TEXT NOT NULL,
+        source TEXT NOT NULL,
+        old_pubkey_fingerprint TEXT,
+        new_pubkey_fingerprint TEXT,
+        replaced BOOLEAN NOT NULL,
+        registered_at TIMESTAMPTZ NOT NULL DEFAULT now()
+      )
+    `);
+  }
+
+  async function loadFromDb() {
+    if (!usePrisma) return;
+    try {
+      await ensureStore();
+      const rows = await prisma.$queryRawUnsafe(`
+        SELECT tenant_id, pubkey, crypto_versions_json, registered_at
+        FROM codex_daemon_e2ee_keys
+      `);
+      for (const row of rows) {
+        let cryptoVersions = ["e2ee-v1"];
+        try { cryptoVersions = normalizeCodexCryptoVersions(JSON.parse(row.crypto_versions_json)); } catch {}
+        pubkeys.set(row.tenant_id, {
+          pubkey: row.pubkey,
+          crypto_versions: cryptoVersions,
+          registered_at: row.registered_at instanceof Date ? row.registered_at.toISOString() : String(row.registered_at),
+        });
+      }
+      logger.log("codex-relay: loaded " + rows.length + " persisted E2EE daemon pubkey(s)");
+    } catch (err) {
+      logger.error("codex-relay: failed to load persisted E2EE daemon pubkeys:", err.message);
+      if (!devMode) process.exit(1);
+    }
+  }
+
+  async function persist(agentId, pubkey, cryptoVersions) {
+    if (!usePrisma) return;
+    await ensureStore();
+    await prisma.$executeRawUnsafe(
+      `INSERT INTO codex_daemon_e2ee_keys
+        (tenant_id, pubkey, crypto_versions_json, registered_at)
+       VALUES ($1, $2, $3, now())
+       ON CONFLICT (tenant_id)
+       DO UPDATE SET
+        pubkey = EXCLUDED.pubkey,
+        crypto_versions_json = EXCLUDED.crypto_versions_json,
+        registered_at = EXCLUDED.registered_at`,
+      agentId,
+      pubkey,
+      JSON.stringify(cryptoVersions),
+    );
+  }
+
+  async function recordAudit(agentId, previousPubkey, nextPubkey, source, registeredAt) {
+    const oldFingerprint = codexDaemonPubkeyFingerprint(previousPubkey);
+    const newFingerprint = codexDaemonPubkeyFingerprint(nextPubkey);
+    const replaced = !!(previousPubkey && previousPubkey !== nextPubkey);
+    const entry = {
+      tenant_id: agentId,
+      source,
+      old_pubkey_fingerprint: oldFingerprint,
+      new_pubkey_fingerprint: newFingerprint,
+      replaced,
+      registered_at: registeredAt,
+    };
+    auditLog.push(entry);
+    if (!usePrisma) return;
+    await ensureAuditStore();
+    await prisma.$executeRawUnsafe(
+      `INSERT INTO codex_daemon_e2ee_key_audit
+        (id, tenant_id, source, old_pubkey_fingerprint, new_pubkey_fingerprint, replaced, registered_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7::timestamptz)`,
+      randomUUID(),
+      agentId,
+      source,
+      oldFingerprint,
+      newFingerprint,
+      replaced,
+      registeredAt,
+    );
+  }
+
+  function register(agentId, pubkey, cryptoVersions, source) {
+    if (typeof agentId !== "string" || !agentId) return Promise.resolve(false);
+    if (typeof pubkey !== "string" || !pubkey || pubkey.length > 1024) return Promise.resolve(false);
+    const previous = pubkeys.get(agentId) || null;
+    const normalizedVersions = normalizeCodexCryptoVersions(cryptoVersions);
+    const registeredAt = new Date().toISOString();
+    pubkeys.set(agentId, {
+      pubkey,
+      crypto_versions: normalizedVersions,
+      registered_at: registeredAt,
+    });
+    logger.log("codex-relay: registered E2EE pubkey for " + agentId + " via " + source);
+    return persist(agentId, pubkey, normalizedVersions)
+      .then(() => recordAudit(agentId, previous?.pubkey || null, pubkey, source, registeredAt))
+      .then(() => ({
+        registered: true,
+        replaced: !!(previous?.pubkey && previous.pubkey !== pubkey),
+        old_fingerprint: codexDaemonPubkeyFingerprint(previous?.pubkey || null),
+        new_fingerprint: codexDaemonPubkeyFingerprint(pubkey),
+      }))
+      .catch((err) => {
+        logger.error("codex-relay: failed to persist E2EE pubkey for " + agentId + ":", err.message);
+        if (!devMode) throw err;
+        return false;
+      });
+  }
+
+  return {
+    pubkeys,
+    auditLog,
+    ensureStore,
+    ensureAuditStore,
+    loadFromDb,
+    register,
+    get(agentId) {
+      return pubkeys.get(agentId) || null;
+    },
+    clearMemoryForTest() {
+      pubkeys.clear();
+    },
+  };
+}

package/src/hosted-mcp/codex-relay-ws-abuse-limits.mjs

@@ -0,0 +1,140 @@
+const DEFAULTS = {
+  maxFrameBytes: 256 * 1024,
+  rateWindowMs: 10_000,
+  maxMessagesPerWindow: 120,
+  maxBytesPerWindow: 1024 * 1024,
+  maxBrowserSocketsPerThread: 8,
+  idleTtlMs: 30 * 60 * 1000,
+  maxMalformedFrames: 3,
+  maxPendingBytes: 1024 * 1024,
+};
+
+export const CODEX_WS_CLOSE_CODES = Object.freeze({
+  oversizedFrame: 4400,
+  rateLimited: 4401,
+  tooManySockets: 4402,
+  idleTimeout: 4403,
+  malformedFrames: 4404,
+  operatorDisabled: 4405,
+  pendingBytes: 4406,
+});
+
+function positiveInt(value, fallback) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function parseAgentSet(value) {
+  if (!value) return new Set();
+  return new Set(
+    String(value)
+      .split(",")
+      .map((part) => part.trim())
+      .filter(Boolean),
+  );
+}
+
+export function createCodexWsAbuseLimitConfig(env = process.env) {
+  return {
+    maxFrameBytes: positiveInt(env.LDM_CODEX_WS_MAX_FRAME_BYTES, DEFAULTS.maxFrameBytes),
+    rateWindowMs: positiveInt(env.LDM_CODEX_WS_RATE_WINDOW_MS, DEFAULTS.rateWindowMs),
+    maxMessagesPerWindow: positiveInt(env.LDM_CODEX_WS_MAX_MESSAGES_PER_WINDOW, DEFAULTS.maxMessagesPerWindow),
+    maxBytesPerWindow: positiveInt(env.LDM_CODEX_WS_MAX_BYTES_PER_WINDOW, DEFAULTS.maxBytesPerWindow),
+    maxBrowserSocketsPerThread: positiveInt(
+      env.LDM_CODEX_WS_MAX_BROWSER_SOCKETS_PER_THREAD,
+      DEFAULTS.maxBrowserSocketsPerThread,
+    ),
+    idleTtlMs: positiveInt(env.LDM_CODEX_WS_IDLE_TTL_MS, DEFAULTS.idleTtlMs),
+    maxMalformedFrames: positiveInt(env.LDM_CODEX_WS_MAX_MALFORMED_FRAMES, DEFAULTS.maxMalformedFrames),
+    maxPendingBytes: positiveInt(env.LDM_CODEX_WS_MAX_PENDING_BYTES, DEFAULTS.maxPendingBytes),
+    killSwitchAll: env.LDM_CODEX_WS_KILL_SWITCH_ALL === "1",
+    killSwitchAgents: parseAgentSet(env.LDM_CODEX_WS_KILL_SWITCH_AGENTS),
+  };
+}
+
+export function isCodexWsAgentDisabled(config, agentId) {
+  return !!(
+    config?.killSwitchAll
+    || (typeof agentId === "string" && config?.killSwitchAgents?.has(agentId))
+  );
+}
+
+function rejected(code, reason) {
+  return { ok: false, code, reason };
+}
+
+export function createCodexWsConnectionGuard({ config, agentId, now = Date.now }) {
+  let windowStartMs = now();
+  let messagesInWindow = 0;
+  let bytesInWindow = 0;
+  let malformedFrames = 0;
+  let lastActivityMs = windowStartMs;
+
+  function resetWindow(nowMs) {
+    windowStartMs = nowMs;
+    messagesInWindow = 0;
+    bytesInWindow = 0;
+  }
+
+  return {
+    observeFrame(byteLength, nowMs = now()) {
+      if (isCodexWsAgentDisabled(config, agentId)) {
+        return rejected(CODEX_WS_CLOSE_CODES.operatorDisabled, "operator disabled");
+      }
+      if (byteLength > config.maxFrameBytes) {
+        return rejected(CODEX_WS_CLOSE_CODES.oversizedFrame, "frame too large");
+      }
+      if (nowMs - windowStartMs > config.rateWindowMs) {
+        resetWindow(nowMs);
+      }
+      messagesInWindow += 1;
+      bytesInWindow += byteLength;
+      lastActivityMs = nowMs;
+      if (messagesInWindow > config.maxMessagesPerWindow) {
+        return rejected(CODEX_WS_CLOSE_CODES.rateLimited, "message rate limit");
+      }
+      if (bytesInWindow > config.maxBytesPerWindow) {
+        return rejected(CODEX_WS_CLOSE_CODES.rateLimited, "byte rate limit");
+      }
+      return { ok: true };
+    },
+    observeMalformed(nowMs = now()) {
+      lastActivityMs = nowMs;
+      malformedFrames += 1;
+      if (malformedFrames > config.maxMalformedFrames) {
+        return rejected(CODEX_WS_CLOSE_CODES.malformedFrames, "malformed frame limit");
+      }
+      return { ok: true };
+    },
+    observePendingBytes(bufferedAmount) {
+      if (bufferedAmount > config.maxPendingBytes) {
+        return rejected(CODEX_WS_CLOSE_CODES.pendingBytes, "pending byte limit");
+      }
+      return { ok: true };
+    },
+    observeIdle(nowMs = now()) {
+      if (nowMs - lastActivityMs > config.idleTtlMs) {
+        return rejected(CODEX_WS_CLOSE_CODES.idleTimeout, "idle timeout");
+      }
+      return { ok: true };
+    },
+  };
+}
+
+export function codexWsFrameByteLength(data) {
+  if (typeof data === "string") return Buffer.byteLength(data);
+  if (Buffer.isBuffer(data)) return data.length;
+  if (data instanceof ArrayBuffer) return data.byteLength;
+  if (ArrayBuffer.isView(data)) return data.byteLength;
+  return Buffer.byteLength(String(data ?? ""));
+}
+
+export function formatCodexWsLimitLog({ agentId, threadId, connectionId, reason }) {
+  return (
+    "codex-relay: websocket limit"
+    + " reason=" + String(reason || "unknown").slice(0, 64)
+    + " agent=" + String(agentId || "<none>").slice(0, 96)
+    + " thread=" + String(threadId || "<none>").slice(0, 96)
+    + " conn=" + String(connectionId || "<none>").slice(0, 64)
+  );
+}

package/src/hosted-mcp/demo/footer.js

@@ -22,7 +22,7 @@
       + '<p style="margin:2px 0 0;">Learning Dreaming Machines</p>'
       + '<p style="margin:8px 0 0;">Copyright &copy; 2026 WIP Computer, Inc. All rights reserved.</p>'
       + '<p style="margin:4px 0 0;">'
-      + '<a href="/legal/privacy/en-ww/" style="color:#a8a4a0;text-decoration:none;">Privacy Policy</a> &nbsp;|&nbsp; '
+      + '<a href="/legal/privacy/" style="color:#a8a4a0;text-decoration:none;">Privacy Policy</a> &nbsp;|&nbsp; '
       + '<a href="/legal/internet-services/terms/site.html" style="color:#a8a4a0;text-decoration:none;">Terms of Use</a></p>'
       + '<p style="margin:4px 0 0;">'
       + '<a href="/agent.txt" style="color:#a8a4a0;text-decoration:none;">Are you an AI Agent?</a></p>'
@@ -31,7 +31,7 @@
     inner.innerHTML = '<p style="margin:0;">WIP Computer, Inc.</p>'
       + '<p style="margin:2px 0 0;">Learning Dreaming Machines</p>'
       + '<p style="margin:8px 0 0;">Copyright &copy; 2026 WIP Computer, Inc. All rights reserved. &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;'
-      + '<a href="/legal/privacy/en-ww/" style="color:#a8a4a0;text-decoration:none;">Privacy Policy</a> &nbsp;|&nbsp; '
+      + '<a href="/legal/privacy/" style="color:#a8a4a0;text-decoration:none;">Privacy Policy</a> &nbsp;|&nbsp; '
       + '<a href="/legal/internet-services/terms/site.html" style="color:#a8a4a0;text-decoration:none;">Terms of Use</a></p>'
       + '<p style="margin:4px 0 0;">'
       + '<a href="/agent.txt" style="color:#a8a4a0;text-decoration:none;">Are you an AI Agent?</a> &nbsp;|&nbsp; '