@jaw.id/cli 0.0.2

package/dist/mcp/server.js

@@ -0,0 +1,658 @@
+import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import * as fs2 from 'fs';
+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
+var rpcMethodSchema = {
+  method: z.string().describe(
+    "EIP-1193 RPC method name (e.g. wallet_connect, wallet_sendCalls, personal_sign). Read the jaw://api-reference resource for the full list and jaw://api-reference/{method} for parameter details."
+  ),
+  params: z.any().optional().describe(
+    "Method parameters \u2014 structure varies by method. Read the jaw://api-reference/{method} resource for the expected format."
+  ),
+  chainId: z.number().optional().describe(
+    "Target chain ID (overrides default). E.g., 1 for Ethereum, 8453 for Base, 84532 for Base Sepolia"
+  )
+};
+var configSetSchema = {
+  key: z.enum(["apiKey", "defaultChain", "keysUrl", "paymasterUrl", "ens"]).describe("Config key"),
+  value: z.string().describe("Config value")
+};
+
+// src/mcp/helpers.ts
+function mcpError(err) {
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: `Error: ${err instanceof Error ? err.message : String(err)}`
+      }
+    ]
+  };
+}
+function mcpResult(data) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(data)
+      }
+    ]
+  };
+}
+var JAW_DIR = path.join(os.homedir(), ".jaw");
+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")
+};
+
+// src/lib/validation.ts
+function isValidKeysUrl(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 === "https:" || parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+    return isTrustedHost && isSecure;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/config.ts
+function ensureDir(dir) {
+  fs2.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs2.chmodSync(dir, 448);
+}
+function loadConfig() {
+  if (!fs2.existsSync(PATHS.config)) {
+    return {};
+  }
+  const raw = fs2.readFileSync(PATHS.config, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(
+      `Config file at ${PATHS.config} is not valid JSON. Run \`jaw config set apiKey=<key>\` to reset it.`
+    );
+  }
+}
+function saveConfig(config) {
+  ensureDir(PATHS.root);
+  fs2.writeFileSync(PATHS.config, JSON.stringify(config, null, 2) + "\n", {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+function redactConfig(config) {
+  return {
+    ...config,
+    apiKey: config.apiKey ? `${config.apiKey.slice(0, 8)}...` : void 0
+  };
+}
+function setConfigValue(key, value) {
+  if (key === "keysUrl" && typeof value === "string" && !isValidKeysUrl(value)) {
+    throw new Error(
+      `Untrusted keysUrl: ${value}. Must be a *.jaw.id domain (HTTPS) or localhost.`
+    );
+  }
+  const config = loadConfig();
+  const updated = { ...config, [key]: value };
+  saveConfig(updated);
+}
+var DEFAULT_TIMEOUT_MS = 12e4;
+var WSBridge = class {
+  port;
+  token;
+  timeout;
+  ws = null;
+  constructor(options) {
+    this.port = options.port;
+    this.token = options.token;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+  }
+  /**
+   * Connect to the daemon's WebSocket server.
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      const url = `ws://127.0.0.1:${this.port}?token=${encodeURIComponent(this.token)}&role=cli`;
+      const ws = new WebSocket(url);
+      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."
+          )
+        );
+      }, 3e4);
+      ws.on("open", () => {
+        clearTimeout(timer);
+        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();
+        } else if (msg.type === "browser_connected") {
+          clearTimeout(timer);
+          resolve();
+        }
+      });
+      ws.on("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+      ws.on("close", () => {
+        clearTimeout(timer);
+      });
+    });
+  }
+  /**
+   * Send an RPC request through the daemon 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");
+    }
+    const id = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(
+          new Error(
+            `Request timed out after ${this.timeout / 1e3}s. Did you complete the action in the browser?`
+          )
+        );
+        this.close();
+      }, this.timeout);
+      const onMessage = (data) => {
+        let msg;
+        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"
+              )
+            );
+          }
+        }
+      };
+      ws.on("message", onMessage);
+      ws.send(
+        JSON.stringify({
+          id,
+          type: "rpc_request",
+          method,
+          params
+        })
+      );
+    });
+  }
+  /**
+   * 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" }));
+    }
+    this.close();
+  }
+  /**
+   * Close the client connection (daemon stays alive).
+   */
+  close() {
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+  }
+};
+
+// 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;
+  }
+  try {
+    const cmd = execSync(`ps -p ${String(pid)} -o command=`, {
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim();
+    return cmd.includes("ws-daemon");
+  } catch {
+    return false;
+  }
+}
+function loadBridgeInfo() {
+  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 {
+      }
+      return null;
+    }
+    return info;
+  } catch {
+    return null;
+  }
+}
+async function getBridge(options) {
+  let info = loadBridgeInfo();
+  if (!info) {
+    info = await spawnDaemon(options);
+  }
+  const bridge = new WSBridge({
+    port: info.port,
+    token: info.token,
+    timeout: options.timeout
+  });
+  await bridge.connect();
+  return bridge;
+}
+async function shutdownDaemon() {
+  const info = loadBridgeInfo();
+  if (!info) return;
+  try {
+    process.kill(info.pid, "SIGTERM");
+  } catch {
+  }
+  try {
+    if (fs2.existsSync(PATHS.bridge)) fs2.unlinkSync(PATHS.bridge);
+  } catch {
+  }
+}
+function acquireLock() {
+  ensureDir(PATHS.root);
+  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 {
+        try {
+          fs2.unlinkSync(LOCK_PATH);
+        } 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");
+    try {
+      if (fs2.existsSync(PATHS.bridge)) fs2.unlinkSync(PATHS.bridge);
+    } 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);
+  }
+}
+
+// src/mcp/handlers/rpc.ts
+function resolveApiKey() {
+  const apiKey = process.env["JAW_API_KEY"] ?? loadConfig().apiKey;
+  if (!apiKey) {
+    throw new Error(
+      "API key required. Set JAW_API_KEY env var or run: jaw config set apiKey <key>"
+    );
+  }
+  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) => {
+      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);
+      }
+    }
+  );
+}
+
+// src/mcp/handlers/config.ts
+function registerConfigTools(server) {
+  server.tool(
+    "jaw_config_show",
+    "Show current CLI configuration (API key redacted).",
+    {},
+    async () => {
+      try {
+        const config = redactConfig(loadConfig());
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(config) }
+          ]
+        };
+      } catch (err) {
+        return mcpError(err);
+      }
+    }
+  );
+  server.tool(
+    "jaw_config_set",
+    "Set a CLI configuration value (apiKey, defaultChain, keysUrl, paymasterUrl, ens).",
+    configSetSchema,
+    async (params) => {
+      try {
+        if (params.key === "defaultChain") {
+          const num = parseInt(params.value, 10);
+          if (isNaN(num) || num <= 0) {
+            throw new Error(`Invalid chain ID: ${params.value}`);
+          }
+          setConfigValue(params.key, num);
+        } else {
+          setConfigValue(params.key, params.value);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Set ${params.key} successfully`
+            }
+          ]
+        };
+      } catch (err) {
+        return mcpError(err);
+      }
+    }
+  );
+}
+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.",
+    {},
+    async () => {
+      try {
+        let daemonRunning = false;
+        let daemonPid = null;
+        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;
+          }
+        } catch {
+          daemonRunning = false;
+        }
+        const config = redactConfig(loadConfig());
+        const status = {
+          daemon: daemonRunning ? { running: true, pid: daemonPid } : { running: false },
+          bridgeConnection: isBridgeCached() ? "connected" : "disconnected",
+          config
+        };
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(status, null, 2) }
+          ]
+        };
+      } catch (err) {
+        return mcpError(err);
+      }
+    }
+  );
+  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.",
+    {},
+    async () => {
+      try {
+        closeCachedBridge();
+        await shutdownDaemon();
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Bridge daemon stopped and browser session closed."
+            }
+          ]
+        };
+      } catch (err) {
+        return mcpError(err);
+      }
+    }
+  );
+}
+var DOCS_BASE = "https://docs.jaw.id/api-reference";
+async function fetchDocs(url) {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Failed to fetch docs: ${res.status} ${res.statusText}`);
+  }
+  const html = await res.text();
+  return html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/\s{2,}/g, " ").trim();
+}
+function registerResources(server) {
+  server.resource(
+    "api-reference",
+    "jaw://api-reference",
+    {
+      description: "JAW.id API reference \u2014 lists all supported RPC methods with descriptions. Read this before using the jaw_rpc tool to understand available methods.",
+      mimeType: "text/plain"
+    },
+    async () => ({
+      contents: [
+        {
+          uri: "jaw://api-reference",
+          mimeType: "text/plain",
+          text: await fetchDocs(DOCS_BASE)
+        }
+      ]
+    })
+  );
+  server.resource(
+    "api-reference-method",
+    new ResourceTemplate("jaw://api-reference/{method}", { list: void 0 }),
+    {
+      description: "Detailed documentation for a specific RPC method including parameters, request/response format, and examples. Use the method name from the api-reference overview (e.g. wallet_sendCalls, personal_sign).",
+      mimeType: "text/plain"
+    },
+    async (uri, variables) => {
+      const method = String(variables.method);
+      if (!/^[\w_]+$/.test(method)) {
+        throw new Error(
+          `Invalid method name: "${method}". Expected an RPC method like wallet_sendCalls.`
+        );
+      }
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "text/plain",
+            text: await fetchDocs(`${DOCS_BASE}/${method}`)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/server.ts
+function createMcpServer() {
+  const server = new McpServer({
+    name: "jaw",
+    version: "0.0.1"
+  });
+  registerRpcTool(server);
+  registerConfigTools(server);
+  registerDaemonTools(server);
+  registerResources(server);
+  return server;
+}
+async function startMcpServer() {
+  const server = createMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+export { createMcpServer, startMcpServer };
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map