@jaw.id/cli 0.0.3 → 0.0.7

package/dist/mcp/server.js

@@ -2,11 +2,9 @@ import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mc
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { z } from 'zod';
 import * as fs2 from 'fs';
+import * as crypto from 'crypto';
 import * as path from 'path';
-import { fileURLToPath } from 'url';
-import { spawn, execSync } from 'child_process';
 import * as os from 'os';
-import * as crypto from 'crypto';
 import WebSocket from 'ws';
 
 // src/mcp/server.ts
@@ -22,7 +20,7 @@ var rpcMethodSchema = {
   )
 };
 var configSetSchema = {
-  key: z.enum(["apiKey", "defaultChain", "keysUrl", "paymasterUrl", "ens"]).describe("Config key"),
+  key: z.enum(["apiKey", "defaultChain", "keysUrl", "paymasterUrl", "ens", "relayUrl"]).describe("Config key"),
   value: z.string().describe("Config value")
 };
 
@@ -53,8 +51,7 @@ var PATHS = {
   root: JAW_DIR,
   config: path.join(JAW_DIR, "config.json"),
   session: path.join(JAW_DIR, "session.json"),
-  bridge: path.join(JAW_DIR, "bridge.json"),
-  daemonLog: path.join(JAW_DIR, "daemon.log")
+  relay: path.join(JAW_DIR, "relay.json")
 };
 
 // src/lib/validation.ts
@@ -68,6 +65,17 @@ function isValidKeysUrl(url) {
     return false;
   }
 }
+function isValidRelayUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const isTrustedHost = parsed.hostname.endsWith(".jaw.id") || parsed.hostname === "jaw.id" || parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+    const isSecure = parsed.protocol === "wss:" || parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+    const isWebSocket = parsed.protocol === "wss:" || parsed.protocol === "ws:";
+    return isTrustedHost && isSecure && isWebSocket;
+  } catch {
+    return false;
+  }
+}
 
 // src/lib/config.ts
 function ensureDir(dir) {
@@ -106,53 +114,226 @@ function setConfigValue(key, value) {
       `Untrusted keysUrl: ${value}. Must be a *.jaw.id domain (HTTPS) or localhost.`
     );
   }
+  if (key === "relayUrl" && typeof value === "string" && !isValidRelayUrl(value)) {
+    throw new Error(
+      `Untrusted relayUrl: ${value}. Must be wss://*.jaw.id or ws://localhost.`
+    );
+  }
   const config = loadConfig();
   const updated = { ...config, [key]: value };
   saveConfig(updated);
 }
+
+// src/lib/crypto.ts
+var subtle = globalThis.crypto.subtle;
+async function generateKeyPair() {
+  return subtle.generateKey(
+    { name: "ECDH", namedCurve: "P-256" },
+    true,
+    ["deriveKey"]
+  );
+}
+async function deriveSharedSecret(privateKey, peerPublicKey) {
+  return subtle.deriveKey(
+    { name: "ECDH", public: peerPublicKey },
+    privateKey,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function encryptMessage(sharedSecret, payload) {
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12));
+  const plaintext = new TextEncoder().encode(JSON.stringify(payload));
+  const cipherBuf = await subtle.encrypt(
+    { name: "AES-GCM", iv },
+    sharedSecret,
+    plaintext
+  );
+  return {
+    iv: bufferToBase64(iv),
+    ciphertext: bufferToBase64(new Uint8Array(cipherBuf))
+  };
+}
+async function decryptMessage(sharedSecret, envelope) {
+  const iv = Buffer.from(envelope.iv, "base64");
+  const ciphertext = Buffer.from(envelope.ciphertext, "base64");
+  const plainBuf = await subtle.decrypt(
+    { name: "AES-GCM", iv },
+    sharedSecret,
+    ciphertext
+  );
+  return JSON.parse(new TextDecoder().decode(plainBuf));
+}
+async function exportKeyToHex(type, key) {
+  const format = type === "private" ? "pkcs8" : "spki";
+  const buf = await subtle.exportKey(format, key);
+  return bytesToHex(new Uint8Array(buf));
+}
+async function importKeyFromHex(type, hex) {
+  const format = type === "private" ? "pkcs8" : "spki";
+  return subtle.importKey(
+    format,
+    Buffer.from(hexToBytes(hex)),
+    { name: "ECDH", namedCurve: "P-256" },
+    true,
+    type === "private" ? ["deriveKey"] : []
+  );
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(hex) {
+  if (hex.length % 2 !== 0) throw new Error("Invalid hex: odd length");
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+  }
+  return bytes;
+}
+function bufferToBase64(buf) {
+  return Buffer.from(buf).toString("base64");
+}
+
+// src/lib/ws-bridge.ts
 var DEFAULT_TIMEOUT_MS = 12e4;
+var MAX_MESSAGE_BYTES = 5 * 1024 * 1024;
+var BROWSER_REOPEN_COOLDOWN_MS = 5e3;
+var MAX_RECONNECT_ATTEMPTS = 3;
+var RECONNECT_BASE_DELAY_MS = 1e3;
 var WSBridge = class {
-  port;
-  token;
+  relayUrl;
+  session;
   timeout;
+  config;
+  privateKeyHex;
+  publicKeyHex;
+  peerPublicKeyHex;
+  sharedSecret = null;
   ws = null;
+  disposed = false;
+  // Auto-reopen browser state
+  onBrowserNeeded;
+  onPeerKeyChanged;
+  lastBrowserOpenTime = 0;
+  // Reconnection state
+  reconnectAttempts = 0;
+  /** Updated after key exchange — caller should persist this. */
+  get peerPublicKey() {
+    return this.peerPublicKeyHex;
+  }
   constructor(options) {
-    this.port = options.port;
-    this.token = options.token;
+    this.relayUrl = options.relayUrl;
+    this.session = options.session;
     this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.config = options.config;
+    this.privateKeyHex = options.privateKeyHex;
+    this.publicKeyHex = options.publicKeyHex;
+    this.peerPublicKeyHex = options.peerPublicKeyHex;
   }
   /**
-   * Connect to the daemon's WebSocket server.
+   * Connect to the relay and wait for the browser to be ready.
+   *
+   * @param onBrowserNeeded — called when the relay reports no browser connected.
+   * @param onPeerKeyChanged — called when a key_exchange updates the peer key.
    */
-  async connect() {
+  async connect(onBrowserNeeded, onPeerKeyChanged) {
+    this.onBrowserNeeded = onBrowserNeeded;
+    this.onPeerKeyChanged = onPeerKeyChanged;
+    if (this.peerPublicKeyHex) {
+      await this.deriveSecret();
+    }
+    return this.connectInternal(onBrowserNeeded, onPeerKeyChanged);
+  }
+  async connectInternal(onBrowserNeeded, onPeerKeyChanged) {
     return new Promise((resolve, reject) => {
-      const url = `ws://127.0.0.1:${this.port}?token=${encodeURIComponent(this.token)}&role=cli`;
+      const url = `${this.relayUrl}?session=${encodeURIComponent(this.session)}&role=cli`;
       const ws = new WebSocket(url);
+      let browserOpened = false;
+      let resolved = false;
+      let expectingKeyExchange = !this.peerPublicKeyHex;
       const timer = setTimeout(() => {
         ws.close();
         reject(
           new Error(
-            "Browser SDK did not connect in time.\nIf the browser tab failed to open, run `jaw disconnect` then try again."
+            "Browser did not connect in time.\nRun `jaw disconnect` then try again."
           )
         );
       }, 3e4);
-      ws.on("open", () => {
+      const sendEncryptedInit = async () => {
+        if (!this.sharedSecret) return;
+        const envelope = await encryptMessage(this.sharedSecret, {
+          type: "init",
+          apiKey: this.config.apiKey,
+          chainId: this.config.chainId,
+          ens: this.config.ens,
+          paymasterUrl: this.config.paymasterUrl
+        });
+        this.sendRaw(ws, JSON.stringify({ type: "encrypted", ...envelope }));
+      };
+      const waitForReady = () => {
+        const readyTimer = setTimeout(() => {
+          ws.close();
+          reject(new Error("Browser SDK did not become ready in time."));
+        }, 15e3);
+        const onMsg = async (data) => {
+          const msg = safeParse(data);
+          if (!msg) return;
+          if (msg.type === "encrypted" && this.sharedSecret) {
+            try {
+              const inner = await decryptMessage(
+                this.sharedSecret,
+                msg
+              );
+              if (inner.type === "ready") {
+                clearTimeout(readyTimer);
+                ws.off("message", onMsg);
+                this.reconnectAttempts = 0;
+                resolve();
+              }
+            } catch {
+            }
+          }
+        };
+        ws.on("message", onMsg);
+      };
+      const onBrowserReady = async () => {
+        if (resolved) return;
+        resolved = true;
         clearTimeout(timer);
+        waitForReady();
+        await sendEncryptedInit();
+      };
+      ws.on("open", () => {
         this.ws = ws;
       });
-      ws.on("message", (data) => {
-        let msg;
-        try {
-          msg = JSON.parse(data.toString());
-        } catch {
-          return;
-        }
-        if (msg.type === "status" && msg.browserConnected) {
-          clearTimeout(timer);
-          resolve();
+      ws.on("message", async (data) => {
+        const msg = safeParse(data);
+        if (!msg) return;
+        if (msg.type === "status") {
+          if (msg.browserConnected) {
+            if (this.sharedSecret) {
+              await onBrowserReady();
+            } else {
+              expectingKeyExchange = true;
+            }
+          } else if (!browserOpened && onBrowserNeeded) {
+            browserOpened = true;
+            expectingKeyExchange = true;
+            onBrowserNeeded().catch(() => {
+            });
+          }
         } else if (msg.type === "browser_connected") {
-          clearTimeout(timer);
-          resolve();
+          expectingKeyExchange = true;
+        } else if (msg.type === "browser_disconnected") {
+          this.handleBrowserDisconnect();
+        } else if (msg.type === "key_exchange" && expectingKeyExchange) {
+          expectingKeyExchange = false;
+          const peerKey = msg.publicKey;
+          this.peerPublicKeyHex = peerKey;
+          await this.deriveSecret();
+          onPeerKeyChanged?.(peerKey);
+          await onBrowserReady();
         }
       });
       ws.on("error", (err) => {
@@ -161,18 +342,32 @@ var WSBridge = class {
       });
       ws.on("close", () => {
         clearTimeout(timer);
+        if (!this.disposed) {
+          this.handleRelayDisconnect();
+        }
       });
     });
   }
   /**
-   * Send an RPC request through the daemon to the browser SDK.
+   * Send an encrypted RPC request through the relay to the browser SDK.
    */
   async request(method, params) {
     const ws = this.ws;
     if (!ws || ws.readyState !== WebSocket.OPEN) {
-      throw new Error("Not connected to bridge daemon");
+      throw new Error("Not connected to relay");
+    }
+    if (!this.sharedSecret) {
+      throw new Error("No shared secret \u2014 key exchange not completed");
     }
     const id = crypto.randomUUID();
+    const envelope = await encryptMessage(this.sharedSecret, {
+      type: "rpc_request",
+      id,
+      method,
+      params
+    });
+    const serialized = JSON.stringify({ type: "encrypted", ...envelope });
+    assertMessageSize(serialized, method);
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         reject(
@@ -182,58 +377,91 @@ var WSBridge = class {
         );
         this.close();
       }, this.timeout);
-      const onMessage = (data) => {
-        let msg;
+      const onMessage = async (data) => {
+        const msg = safeParse(data);
+        if (!msg || msg.type !== "encrypted" || !this.sharedSecret) return;
         try {
-          msg = JSON.parse(data.toString());
-        } catch {
-          return;
-        }
-        if (msg.type === "rpc_response" && msg.id === id) {
-          clearTimeout(timer);
-          ws.off("message", onMessage);
-          if (msg.success) {
-            resolve(msg.data);
-          } else {
-            const err = msg.error;
-            reject(
-              new Error(
-                err ? `[${err.code}] ${err.message}` : "Request failed"
-              )
-            );
+          const inner = await decryptMessage(
+            this.sharedSecret,
+            msg
+          );
+          if (inner.type === "rpc_response" && inner.id === id) {
+            clearTimeout(timer);
+            ws.off("message", onMessage);
+            if (inner.success) {
+              resolve(inner.data);
+            } else {
+              const err = inner.error;
+              reject(
+                new Error(
+                  err ? `[${err.code}] ${err.message}` : "Request failed"
+                )
+              );
+            }
           }
+        } catch {
         }
       };
       ws.on("message", onMessage);
-      ws.send(
-        JSON.stringify({
-          id,
-          type: "rpc_request",
-          method,
-          params
-        })
-      );
+      this.sendRaw(ws, serialized);
     });
   }
-  /**
-   * Check if the WebSocket connection is open.
-   */
   isOpen() {
     return this.ws?.readyState === WebSocket.OPEN;
   }
-  /**
-   * Send a shutdown signal to the daemon.
-   */
-  shutdown() {
-    if (this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify({ type: "shutdown" }));
+  async shutdown() {
+    this.disposed = true;
+    if (this.ws?.readyState === WebSocket.OPEN && this.sharedSecret) {
+      try {
+        const envelope = await encryptMessage(this.sharedSecret, {
+          type: "shutdown"
+        });
+        this.sendRaw(
+          this.ws,
+          JSON.stringify({ type: "encrypted", ...envelope })
+        );
+      } catch {
+      }
     }
     this.close();
   }
   /**
-   * Close the client connection (daemon stays alive).
+   * Connect to relay and send shutdown directly — no init/ready handshake.
+   * Used by `jaw disconnect` when we just need to tell the browser to close.
    */
+  async connectAndShutdown() {
+    if (!this.peerPublicKeyHex) {
+      return;
+    }
+    this.disposed = true;
+    await this.deriveSecret();
+    return new Promise((resolve) => {
+      const url = `${this.relayUrl}?session=${encodeURIComponent(this.session)}&role=cli`;
+      const ws = new WebSocket(url);
+      const timer = setTimeout(() => {
+        try {
+          ws.close();
+        } catch {
+        }
+        resolve();
+      }, 3e3);
+      ws.on("open", async () => {
+        this.ws = ws;
+        try {
+          await this.shutdown();
+        } catch {
+        }
+        clearTimeout(timer);
+        resolve();
+      });
+      ws.on("error", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+  }
   close() {
+    this.disposed = true;
     if (this.ws) {
       try {
         this.ws.close();
@@ -242,182 +470,211 @@ var WSBridge = class {
       this.ws = null;
     }
   }
+  /**
+   * Auto-reopen browser when browser_disconnected is received from relay.
+   * Respects a cooldown to prevent rapid re-opening.
+   */
+  handleBrowserDisconnect() {
+    if (this.disposed || !this.onBrowserNeeded) return;
+    const now = Date.now();
+    if (now - this.lastBrowserOpenTime < BROWSER_REOPEN_COOLDOWN_MS) {
+      return;
+    }
+    this.lastBrowserOpenTime = now;
+    this.sharedSecret = null;
+    this.peerPublicKeyHex = null;
+    this.onBrowserNeeded().catch(() => {
+    });
+  }
+  /**
+   * Attempt to reconnect to the relay with exponential backoff
+   * when the WebSocket connection drops unexpectedly.
+   */
+  handleRelayDisconnect() {
+    if (this.disposed) return;
+    if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) return;
+    const delay = RECONNECT_BASE_DELAY_MS * Math.pow(2, this.reconnectAttempts);
+    this.reconnectAttempts++;
+    setTimeout(() => {
+      if (this.disposed) return;
+      this.connectInternal(this.onBrowserNeeded, this.onPeerKeyChanged).catch(
+        () => {
+        }
+      );
+    }, delay);
+  }
+  /** Send a raw string over the WebSocket, enforcing message size limits. */
+  sendRaw(ws, data) {
+    ws.send(data);
+  }
+  async deriveSecret() {
+    if (!this.peerPublicKeyHex) return;
+    const privateKey = await importKeyFromHex("private", this.privateKeyHex);
+    const peerPublicKey = await importKeyFromHex(
+      "public",
+      this.peerPublicKeyHex
+    );
+    this.sharedSecret = await deriveSharedSecret(privateKey, peerPublicKey);
+  }
 };
-
-// src/lib/bridge-singleton.ts
-function findDistDir() {
-  let dir = path.dirname(fileURLToPath(import.meta.url));
-  for (let i = 0; i < 10; i++) {
-    const candidate = path.join(dir, "lib", "ws-daemon.js");
-    if (fs2.existsSync(candidate)) return dir;
-    dir = path.dirname(dir);
-  }
-  throw new Error("Cannot find ws-daemon.js in dist tree");
-}
-var JAW_KEYS_URL = "https://keys.jaw.id";
-var LOCK_PATH = path.join(PATHS.root, "daemon.lock");
-function isDaemonProcess(pid) {
-  if (!Number.isInteger(pid) || pid <= 0 || pid > 4194304) return false;
-  try {
-    process.kill(pid, 0);
-  } catch {
-    return false;
+function assertMessageSize(serialized, method) {
+  const byteLength = Buffer.byteLength(serialized, "utf-8");
+  if (byteLength > MAX_MESSAGE_BYTES) {
+    const sizeMB = (byteLength / (1024 * 1024)).toFixed(2);
+    throw new Error(
+      `Message for ${method} is too large (${sizeMB} MB, limit ${MAX_MESSAGE_BYTES / (1024 * 1024)} MB). Try reducing the number of calls in your batch.`
+    );
   }
+}
+function safeParse(data) {
   try {
-    const cmd = execSync(`ps -p ${String(pid)} -o command=`, {
-      encoding: "utf-8",
-      timeout: 3e3
-    }).trim();
-    return cmd.includes("ws-daemon");
+    return JSON.parse(data.toString());
   } catch {
-    return false;
+    return null;
   }
 }
-function loadBridgeInfo() {
+
+// src/lib/bridge-singleton.ts
+var DEFAULT_KEYS_URL = "https://keys.jaw.id";
+var DEFAULT_RELAY_URL = "wss://relay.jaw.id";
+function loadRelaySession() {
   try {
-    if (!fs2.existsSync(PATHS.bridge)) return null;
-    const raw = fs2.readFileSync(PATHS.bridge, "utf-8");
-    const info = JSON.parse(raw);
-    if (!isDaemonProcess(info.pid)) {
-      try {
-        fs2.unlinkSync(PATHS.bridge);
-      } catch {
-      }
+    if (!fs2.existsSync(PATHS.relay)) return null;
+    const raw = fs2.readFileSync(PATHS.relay, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.session || !parsed.relayUrl || !parsed.privateKey || !parsed.publicKey) {
       return null;
     }
-    return info;
+    return parsed;
   } catch {
     return null;
   }
 }
+function saveRelaySession(info) {
+  ensureDir(PATHS.root);
+  fs2.writeFileSync(PATHS.relay, JSON.stringify(info, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+function deleteRelaySession() {
+  try {
+    if (fs2.existsSync(PATHS.relay)) fs2.unlinkSync(PATHS.relay);
+  } catch {
+  }
+}
 async function getBridge(options) {
-  let info = loadBridgeInfo();
-  if (!info) {
-    info = await spawnDaemon(options);
+  const config = loadConfig();
+  const keysUrl = options.keysUrl ?? config.keysUrl ?? DEFAULT_KEYS_URL;
+  const relayUrl = options.relayUrl ?? config.relayUrl ?? DEFAULT_RELAY_URL;
+  const chainId = options.chainId ?? config.defaultChain ?? 1;
+  if (!isValidKeysUrl(keysUrl)) {
+    throw new Error(`Untrusted keysUrl: ${keysUrl}. Must be a *.jaw.id domain (HTTPS) or localhost.`);
+  }
+  if (!isValidRelayUrl(relayUrl)) {
+    throw new Error(`Untrusted relayUrl: ${relayUrl}. Must be wss://*.jaw.id or ws://localhost.`);
   }
+  let relaySession = loadRelaySession();
+  if (relaySession && relaySession.relayUrl === relayUrl) {
+    try {
+      return await connectBridge(relaySession, options, chainId, keysUrl, relayUrl);
+    } catch {
+      deleteRelaySession();
+      relaySession = null;
+    }
+  }
+  const session = await createNewSession(relayUrl);
+  saveRelaySession(session);
+  return await connectBridge(session, options, chainId, keysUrl, relayUrl);
+}
+async function createNewSession(relayUrl) {
+  const kp = await generateKeyPair();
+  const privateKey = await exportKeyToHex("private", kp.privateKey);
+  const publicKey = await exportKeyToHex("public", kp.publicKey);
+  return {
+    session: crypto.randomUUID(),
+    relayUrl,
+    privateKey,
+    publicKey,
+    peerPublicKey: null,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function connectBridge(relaySession, options, chainId, keysUrl, relayUrl) {
+  const config = loadConfig();
   const bridge = new WSBridge({
-    port: info.port,
-    token: info.token,
-    timeout: options.timeout
+    relayUrl,
+    session: relaySession.session,
+    timeout: options.timeout,
+    config: {
+      apiKey: options.apiKey,
+      chainId,
+      ens: options.ens ?? config.ens,
+      paymasterUrl: options.paymasterUrl ?? config.paymasterUrl
+    },
+    privateKeyHex: relaySession.privateKey,
+    publicKeyHex: relaySession.publicKey,
+    peerPublicKeyHex: relaySession.peerPublicKey
   });
-  await bridge.connect();
+  await bridge.connect(
+    // onBrowserNeeded
+    async () => {
+      const bridgeUrl = buildBridgeUrl(keysUrl, relaySession.session, relayUrl, relaySession.publicKey);
+      const { default: open } = await import('open');
+      await open(bridgeUrl);
+    },
+    // onPeerKeyChanged
+    (newPeerKey) => {
+      relaySession.peerPublicKey = newPeerKey;
+      saveRelaySession(relaySession);
+    }
+  );
   return bridge;
 }
+function buildBridgeUrl(keysUrl, session, relayUrl, cliPublicKeyHex) {
+  const url = new URL("/cli-bridge", keysUrl);
+  url.searchParams.set("session", session);
+  url.searchParams.set("relay", relayUrl);
+  url.hash = `pk=${cliPublicKeyHex}`;
+  return url.toString();
+}
 async function shutdownDaemon() {
-  const info = loadBridgeInfo();
-  if (!info) return;
+  const session = loadRelaySession();
+  if (!session) return;
   try {
-    process.kill(info.pid, "SIGTERM");
-  } catch {
-  }
-  try {
-    if (fs2.existsSync(PATHS.bridge)) fs2.unlinkSync(PATHS.bridge);
+    const bridge = new WSBridge({
+      relayUrl: session.relayUrl,
+      session: session.session,
+      timeout: 5e3,
+      config: { apiKey: "", chainId: 1 },
+      privateKeyHex: session.privateKey,
+      publicKeyHex: session.publicKey,
+      peerPublicKeyHex: session.peerPublicKey
+    });
+    await bridge.connectAndShutdown();
   } catch {
   }
-}
-function acquireLock() {
-  ensureDir(PATHS.root);
+  deleteRelaySession();
+  const legacyBridge = PATHS.root + "/bridge.json";
+  const legacyLog = PATHS.root + "/daemon.log";
+  const legacyLock = PATHS.root + "/daemon.lock";
   try {
-    const fd = fs2.openSync(LOCK_PATH, "wx");
-    fs2.writeFileSync(LOCK_PATH, String(process.pid), { mode: 384 });
-    return fd;
-  } catch (err) {
-    if (err.code === "EEXIST") {
-      try {
-        const lockPid = parseInt(fs2.readFileSync(LOCK_PATH, "utf-8").trim(), 10);
-        if (Number.isInteger(lockPid) && lockPid > 0) {
-          try {
-            process.kill(lockPid, 0);
-            return null;
-          } catch {
-            try {
-              fs2.unlinkSync(LOCK_PATH);
-            } catch {
-            }
-            return acquireLock();
-          }
-        }
-      } catch {
+    if (fs2.existsSync(legacyBridge)) {
+      const info = JSON.parse(fs2.readFileSync(legacyBridge, "utf-8"));
+      if (info.pid && Number.isInteger(info.pid) && info.pid > 0) {
         try {
-          fs2.unlinkSync(LOCK_PATH);
+          process.kill(info.pid, "SIGTERM");
         } catch {
         }
       }
-      return null;
     }
-    throw err;
-  }
-}
-function releaseLock(fd) {
-  try {
-    fs2.closeSync(fd);
   } catch {
   }
-  try {
-    fs2.unlinkSync(LOCK_PATH);
-  } catch {
-  }
-}
-async function spawnDaemon(options) {
-  ensureDir(PATHS.root);
-  const lockFd = acquireLock();
-  if (lockFd === null) {
-    const deadline = Date.now() + 15e3;
-    while (Date.now() < deadline) {
-      await new Promise((r) => setTimeout(r, 300));
-      const info = loadBridgeInfo();
-      if (info) return info;
-    }
-    throw new Error(
-      "Another process is starting the daemon. Timed out waiting for it."
-    );
-  }
-  try {
-    const existing = loadBridgeInfo();
-    if (existing) return existing;
-    const config = loadConfig();
-    const keysUrl = options.keysUrl ?? config.keysUrl ?? JAW_KEYS_URL;
-    if (!isValidKeysUrl(keysUrl)) {
-      throw new Error(
-        `Untrusted keysUrl: ${keysUrl}. Must be a *.jaw.id domain (HTTPS) or localhost.`
-      );
-    }
-    const daemonArgs = {
-      keysUrl,
-      chainId: options.chainId ?? config.defaultChain ?? 1,
-      ens: options.ens ?? config.ens,
-      paymasterUrl: options.paymasterUrl ?? config.paymasterUrl,
-      timeout: options.timeout ?? 12e4
-    };
-    const daemonScript = path.join(findDistDir(), "lib", "ws-daemon.js");
+  for (const f of [legacyBridge, legacyLog, legacyLock]) {
     try {
-      if (fs2.existsSync(PATHS.bridge)) fs2.unlinkSync(PATHS.bridge);
+      if (fs2.existsSync(f)) fs2.unlinkSync(f);
     } catch {
     }
-    const logFd = fs2.openSync(PATHS.daemonLog, "w", 384);
-    const child = spawn(
-      process.execPath,
-      [daemonScript, JSON.stringify(daemonArgs)],
-      {
-        detached: true,
-        stdio: ["ignore", logFd, logFd],
-        // Pass API key via env var instead of process args to avoid ps aux exposure
-        env: { ...process.env, JAW_DAEMON_API_KEY: options.apiKey }
-      }
-    );
-    child.unref();
-    fs2.closeSync(logFd);
-    const deadline = Date.now() + 15e3;
-    while (Date.now() < deadline) {
-      await new Promise((r) => setTimeout(r, 200));
-      const info = loadBridgeInfo();
-      if (info) return info;
-    }
-    throw new Error(
-      `Daemon failed to start within 15s. Check ${PATHS.daemonLog} for details.`
-    );
-  } finally {
-    releaseLock(lockFd);
   }
 }
 
@@ -431,46 +688,28 @@ function resolveApiKey() {
   }
   return apiKey;
 }
-var cachedBridge = null;
-async function getOrCreateBridge(chainId) {
-  if (cachedBridge && cachedBridge.isOpen()) {
-    return cachedBridge;
-  }
-  const config = loadConfig();
-  const apiKey = resolveApiKey();
-  cachedBridge = await getBridge({
-    keysUrl: config.keysUrl,
-    apiKey,
-    chainId: chainId ?? config.defaultChain,
-    ens: config.ens,
-    paymasterUrl: config.paymasterUrl
-  });
-  return cachedBridge;
-}
-function closeCachedBridge() {
-  if (cachedBridge) {
-    cachedBridge.close();
-    cachedBridge = null;
-  }
-}
-function isBridgeCached() {
-  return cachedBridge !== null && cachedBridge.isOpen();
-}
 function registerRpcTool(server) {
   server.tool(
     "jaw_rpc",
     "Execute any JAW.id wallet RPC method via the browser bridge. Supports transactions, signing, permissions, and queries. Methods that require signing will open the browser for passkey authentication. IMPORTANT: Read the jaw://api-reference resource for the full list of methods, and jaw://api-reference/{method} for detailed parameter formats and examples.",
     rpcMethodSchema,
     async (params) => {
+      const config = loadConfig();
+      const apiKey = resolveApiKey();
+      const bridge = await getBridge({
+        keysUrl: config.keysUrl,
+        apiKey,
+        chainId: params.chainId ?? config.defaultChain,
+        ens: config.ens,
+        paymasterUrl: config.paymasterUrl
+      });
       try {
-        const bridge = await getOrCreateBridge(params.chainId);
         const result = await bridge.request(params.method, params.params);
         return mcpResult(result);
       } catch (err) {
-        if (cachedBridge && !cachedBridge.isOpen()) {
-          cachedBridge = null;
-        }
         return mcpError(err);
+      } finally {
+        bridge.close();
       }
     }
   );
@@ -497,7 +736,7 @@ function registerConfigTools(server) {
   );
   server.tool(
     "jaw_config_set",
-    "Set a CLI configuration value (apiKey, defaultChain, keysUrl, paymasterUrl, ens).",
+    "Set a CLI configuration value (apiKey, defaultChain, keysUrl, paymasterUrl, ens, relayUrl).",
     configSetSchema,
     async (params) => {
       try {
@@ -527,26 +766,23 @@ function registerConfigTools(server) {
 function registerDaemonTools(server) {
   server.tool(
     "jaw_status",
-    "Check the current status of the JAW.id bridge \u2014 whether the daemon is running, the bridge connection is active, and what configuration is in use.",
+    "Check the current status of the JAW.id relay bridge \u2014 whether a relay session exists, the bridge connection is active, and what configuration is in use.",
     {},
     async () => {
       try {
-        let daemonRunning = false;
-        let daemonPid = null;
+        let relaySession = false;
         try {
-          if (fs2.existsSync(PATHS.bridge)) {
-            const info = JSON.parse(fs2.readFileSync(PATHS.bridge, "utf-8"));
-            daemonPid = info.pid;
-            process.kill(info.pid, 0);
-            daemonRunning = true;
+          if (fs2.existsSync(PATHS.relay)) {
+            JSON.parse(fs2.readFileSync(PATHS.relay, "utf-8"));
+            relaySession = true;
           }
         } catch {
-          daemonRunning = false;
+          relaySession = false;
         }
         const config = redactConfig(loadConfig());
         const status = {
-          daemon: daemonRunning ? { running: true, pid: daemonPid } : { running: false },
-          bridgeConnection: isBridgeCached() ? "connected" : "disconnected",
+          relay: relaySession ? { session: true } : { session: false },
+          bridgeConnection: "disconnected",
           config
         };
         return {
@@ -561,17 +797,16 @@ function registerDaemonTools(server) {
   );
   server.tool(
     "jaw_disconnect",
-    "Stop the background bridge daemon and close the browser session. Call this when you are done making wallet requests to clean up resources.",
+    "Close the relay session and browser tab. Call this when you are done making wallet requests to clean up resources.",
     {},
     async () => {
       try {
-        closeCachedBridge();
         await shutdownDaemon();
         return {
           content: [
             {
               type: "text",
-              text: "Bridge daemon stopped and browser session closed."
+              text: "Relay session closed and browser tab dismissed."
             }
           ]
         };