@muhaven/mcp 0.1.2 → 0.1.3

package/dist/index.js

@@ -1,4 +1,5 @@
 import { unlink, readFile, mkdir, chmod, writeFile, stat } from 'fs/promises';
+import 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
@@ -77,23 +78,26 @@ function loadMcpConfig(env = process.env) {
 }
 var PRIVKEY_HEX_RE = /^0x[0-9a-fA-F]{64}$/;
 function loadBrokerConfig(env = process.env) {
-  const sessionKeyHex = env.MUHAVEN_BROKER_SESSION_KEY;
-  if (!sessionKeyHex) {
-    throw new Error(
-      "MUHAVEN_BROKER_SESSION_KEY is required (0x-prefixed 32-byte hex). Mint a session key via the dashboard policy-template install flow."
-    );
-  }
-  if (!PRIVKEY_HEX_RE.test(sessionKeyHex)) {
-    throw new Error("MUHAVEN_BROKER_SESSION_KEY must be a 0x-prefixed 32-byte hex string");
+  const sessionKeyHexRaw = env.MUHAVEN_BROKER_SESSION_KEY;
+  let sessionKeyHex;
+  if (sessionKeyHexRaw && sessionKeyHexRaw.length > 0) {
+    if (!PRIVKEY_HEX_RE.test(sessionKeyHexRaw)) {
+      throw new Error("MUHAVEN_BROKER_SESSION_KEY must be a 0x-prefixed 32-byte hex string");
+    }
+    sessionKeyHex = sessionKeyHexRaw;
   }
   const endpoint = env.MUHAVEN_BROKER_ENDPOINT ?? defaultBrokerEndpoint();
   const maxRequestBytes = readEnvInt("MUHAVEN_BROKER_MAX_BYTES", DEFAULT_BROKER_MAX_BYTES, env);
   const requestTimeoutMs = readEnvInt("MUHAVEN_BROKER_TIMEOUT_MS", DEFAULT_BROKER_TIMEOUT_MS, env);
+  const backendBaseUrl = trimTrailingSlash(env.MUHAVEN_BACKEND_URL ?? DEFAULT_BACKEND_URL);
+  const dashboardBaseUrl = trimTrailingSlash(env.MUHAVEN_DASHBOARD_URL ?? DEFAULT_DASHBOARD_URL);
   return {
     endpoint,
     sessionKeyHex,
     maxRequestBytes,
-    requestTimeoutMs
+    requestTimeoutMs,
+    backendBaseUrl,
+    dashboardBaseUrl
   };
 }
 var BrokerClientError = class extends Error {
@@ -732,6 +736,15 @@ function authRequiredPayload() {
     loginCommand: "muhaven-broker login"
   };
 }
+function sessionKeyRequiredPayload(dashboardBaseUrl = "https://muhaven.app") {
+  const mintUrl = `${trimTrailingSlash(dashboardBaseUrl)}/agent/policy/transition`;
+  return {
+    ok: false,
+    code: "SESSION_KEY_REQUIRED",
+    message: `No session key loaded in broker (read-only posture). Mint one via the dashboard at ${mintUrl}, copy the 0x-prefixed hex into MUHAVEN_BROKER_SESSION_KEY, and restart the daemon. Do NOT run \`muhaven-broker login\` for this \u2014 that mints a JWT, not a session key.`,
+    mintUrl
+  };
+}
 
 // src/tools/handlers.ts
 function ok(data) {
@@ -821,6 +834,7 @@ function sortKeys(value) {
   }
   return value;
 }
+var cachedHasSessionKeyProbe = null;
 async function signEnvelope(intent, toolName, summary, deps) {
   const intentHash = computeIntentHash(intent);
   if (!deps.broker) {
@@ -829,8 +843,29 @@ async function signEnvelope(intent, toolName, summary, deps) {
       "position tools require a running muhaven-broker daemon \u2014 see README \xA7Broker setup"
     );
   }
+  const broker = deps.broker;
+  if (cachedHasSessionKeyProbe === null) {
+    cachedHasSessionKeyProbe = (async () => {
+      try {
+        const hello = await broker.hello();
+        return hello.hasSessionKey ?? true;
+      } catch (err2) {
+        cachedHasSessionKeyProbe = null;
+        throw err2;
+      }
+    })();
+  }
+  let hasSessionKey;
   try {
-    const sig = await deps.broker.signHash(intentHash, { tool: toolName, summary });
+    hasSessionKey = await cachedHasSessionKeyProbe;
+  } catch (e) {
+    return mapBrokerError(e);
+  }
+  if (hasSessionKey === false) {
+    return sessionKeyRequiredPayload(deps.dashboardBaseUrl);
+  }
+  try {
+    const sig = await broker.signHash(intentHash, { tool: toolName, summary });
     return ok({
       intentHash,
       unsignedUserOp: {
@@ -842,6 +877,10 @@ async function signEnvelope(intent, toolName, summary, deps) {
       signerAddress: sig.signerAddress
     });
   } catch (e) {
+    if (e instanceof BrokerClientError && e.code === "broker_error" && /session_key_unavailable/.test(e.message)) {
+      cachedHasSessionKeyProbe = Promise.resolve(false);
+      return sessionKeyRequiredPayload(deps.dashboardBaseUrl);
+    }
     return mapBrokerError(e);
   }
 }
@@ -1164,7 +1203,12 @@ function selectRegistry(readOnly) {
 
 // src/server.ts
 var SERVER_NAME = "@muhaven/mcp";
-var SERVER_VERSION = "0.1.0";
+var SERVER_VERSION = resolveServerVersion();
+function resolveServerVersion() {
+  {
+    return "0.1.3";
+  }
+}
 function toJsonInputSchema(schema) {
   return {
     type: "object",
@@ -1238,7 +1282,8 @@ function buildMcpServer(opts) {
       const result = await entry.handler(parsed, {
         backend: opts.backend,
         broker: opts.broker,
-        surface: "mcp"
+        surface: "mcp",
+        dashboardBaseUrl: opts.dashboardBaseUrl
       });
       return toolJsonResponse(result);
     } catch (err2) {
@@ -1300,7 +1345,8 @@ async function runMcpStdioCli(opts = {}) {
   const server = buildMcpServer({
     registry,
     backend,
-    broker: config.readOnly ? void 0 : broker
+    broker: config.readOnly ? void 0 : broker,
+    dashboardBaseUrl: config.dashboardBaseUrl
   });
   const transport = new StdioServerTransport();
   await server.connect(transport);
@@ -1455,7 +1501,7 @@ async function safeJson(res) {
 }
 
 // src/broker/protocol.ts
-var BROKER_PROTOCOL_VERSION = "0.2.0";
+var BROKER_PROTOCOL_VERSION = "0.3.0";
 var HASH_HEX_RE = /^0x[0-9a-fA-F]{64}$/;
 var JWT_RE = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
 function isHashHex(value) {
@@ -1541,6 +1587,21 @@ function parseBrokerRequest(line) {
 function serializeResponse(res) {
   return JSON.stringify(res) + "\n";
 }
+var MissingSessionKeyError = class extends Error {
+  constructor() {
+    super(
+      "session_key_unavailable: daemon booted in read-only posture (no MUHAVEN_BROKER_SESSION_KEY at env-load time). Mint a session key via the dashboard /agent/policy/transition flow, set MUHAVEN_BROKER_SESSION_KEY, and restart the daemon. (Note: `muhaven-broker login` mints a JWT, NOT a session key \u2014 do not loop on that command for this error.)"
+    );
+    this.name = "MissingSessionKeyError";
+  }
+};
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var NullSigner = class {
+  address = ZERO_ADDRESS;
+  async signHash(_hash) {
+    throw new MissingSessionKeyError();
+  }
+};
 var ViemSigner = class {
   account;
   constructor(privateKey) {
@@ -1712,7 +1773,7 @@ async function openKeystore(options = {}) {
 // src/broker/daemon.ts
 var noopLogger = (_e) => {
 };
-async function handleBrokerRequest(req, signer, keystore, nowSec = () => Math.floor(Date.now() / 1e3)) {
+async function handleBrokerRequest(req, signer, keystore, nowSec = () => Math.floor(Date.now() / 1e3), options = {}) {
   switch (req.type) {
     case "hello": {
       let hasJwt = false;
@@ -1722,16 +1783,26 @@ async function handleBrokerRequest(req, signer, keystore, nowSec = () => Math.fl
       } catch {
         hasJwt = false;
       }
+      const hasSessionKey = options.hasSessionKey ?? true;
       return {
         type: "hello",
         version: BROKER_PROTOCOL_VERSION,
         sessionKeyAddress: signer.address,
-        hasJwt
+        hasJwt,
+        hasSessionKey,
+        ...options.effectiveConfig ? { effectiveConfig: options.effectiveConfig } : {}
       };
     }
     case "sign_hash": {
-      const signature = await signer.signHash(req.hash);
-      return { type: "sign_hash", signature, signerAddress: signer.address };
+      try {
+        const signature = await signer.signHash(req.hash);
+        return { type: "sign_hash", signature, signerAddress: signer.address };
+      } catch (err2) {
+        if (err2 instanceof MissingSessionKeyError) {
+          return errorResponse("session_key_unavailable", err2.message);
+        }
+        throw err2;
+      }
     }
     case "store_jwt": {
       try {
@@ -1803,9 +1874,24 @@ var BrokerDaemon = class {
   log;
   config;
   keystore;
+  /**
+   * Whether a session-key private half is actually loaded. `false` =
+   * daemon booted in read-only posture (no `MUHAVEN_BROKER_SESSION_KEY`
+   * at env-load time) and uses a `NullSigner` whose `signHash` throws.
+   */
+  hasSessionKey;
   constructor(options) {
     this.config = options.config;
-    this.signer = options.signer ?? new ViemSigner(options.config.sessionKeyHex);
+    if (options.signer) {
+      this.signer = options.signer;
+      this.hasSessionKey = true;
+    } else if (options.config.sessionKeyHex) {
+      this.signer = new ViemSigner(options.config.sessionKeyHex);
+      this.hasSessionKey = true;
+    } else {
+      this.signer = new NullSigner();
+      this.hasSessionKey = false;
+    }
     this.keystore = options.keystore ?? null;
     this.log = options.logger ?? noopLogger;
     this.server = createServer((socket) => this.onConnection(socket));
@@ -1843,6 +1929,7 @@ var BrokerDaemon = class {
       meta: {
         endpoint: this.config.endpoint,
         signer: this.signer.address,
+        hasSessionKey: this.hasSessionKey,
         keystore: this.keystore.backend,
         version: BROKER_PROTOCOL_VERSION
       }
@@ -1924,7 +2011,19 @@ var BrokerDaemon = class {
       return;
     }
     try {
-      const res = await handleBrokerRequest(parsed, this.signer, this.keystore);
+      const res = await handleBrokerRequest(
+        parsed,
+        this.signer,
+        this.keystore,
+        void 0,
+        {
+          hasSessionKey: this.hasSessionKey,
+          effectiveConfig: {
+            backendBaseUrl: this.config.backendBaseUrl,
+            dashboardBaseUrl: this.config.dashboardBaseUrl
+          }
+        }
+      );
       socket.end(serializeResponse(res));
     } catch (err2) {
       this.log({
@@ -1939,4 +2038,4 @@ var BrokerDaemon = class {
   }
 };
 
-export { BROKER_PROTOCOL_VERSION, BackendClient, BackendError, BrokerClient, BrokerClientError, BrokerDaemon, DeviceFlowAbortedError, DeviceFlowClient, JwtSource, KeystoreError, NoJwtAvailableError, TOOL_DESCRIPTORS, buildMcpServer, buildToolHashTable, defaultBrokerEndpoint, fullToolRegistry, handleBrokerRequest, hashToolDescriptor, loadBrokerConfig, loadMcpConfig, openKeystore, parseBrokerRequest, registryForReadOnly, runMcpStdioCli, selectRegistry, serializeResponse, verifyDescriptorAgainstPin };
+export { BROKER_PROTOCOL_VERSION, BackendClient, BackendError, BrokerClient, BrokerClientError, BrokerDaemon, DeviceFlowAbortedError, DeviceFlowClient, JwtSource, KeystoreError, MissingSessionKeyError, NoJwtAvailableError, NullSigner, SERVER_VERSION, TOOL_DESCRIPTORS, ViemSigner, ZERO_ADDRESS, buildMcpServer, buildToolHashTable, defaultBrokerEndpoint, fullToolRegistry, handleBrokerRequest, hashToolDescriptor, loadBrokerConfig, loadMcpConfig, openKeystore, parseBrokerRequest, registryForReadOnly, runMcpStdioCli, selectRegistry, serializeResponse, verifyDescriptorAgainstPin };

package/manifest.json

@@ -3,7 +3,7 @@
   "manifest_version": "0.2",
   "name": "muhaven-mcp",
   "display_name": "MuHaven (RWA portfolio)",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Confidential RWA portfolio management on Fhenix CoFHE. Read your encrypted balances, propose yield claims and policy changes — all signing happens in a sibling broker daemon, the LLM never sees your private key.",
   "long_description": "MuHaven MCP exposes 22 tools across read.* / position.* / policy.* / issuer.* / governance.* groups for managing real-world asset (RWA) tokens with FHE-encrypted balances. Authentication uses a one-time device-code ceremony (run `muhaven-broker login`); subsequent tool calls fetch the JWT from the broker over a Unix socket. Position / governance tools return unsigned UserOps + broker signatures — they NEVER auto-submit to a bundler. The companion `muhaven-broker` daemon must be running before tools can be invoked. See README for setup.",
   "author": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@muhaven/mcp",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "MuHaven MCP server — read/position/policy toolsets bridging Claude Desktop / Cursor / Claude Code to the MuHaven backend, with a sibling muhaven-broker daemon holding the session-key private half over a local IPC socket",
   "type": "module",
   "repository": {