@agentvalet/mcp-server 0.3.9 → 1.1.0

package/dist/bind.js

@@ -79,14 +79,32 @@ export async function attemptInviteBind(opts) {
         privateKeyEncoding: { type: "pkcs8", format: "pem" },
     });
     const url = `${opts.proxyUrl.replace(/\/$/, "")}/v1/invites/bind`;
-    const res = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-            bind_secret: opts.bindSecret,
-            public_key_pem: publicKey,
-        }),
-    });
+    // 15s hard timeout: Claude Desktop kills the transport at ~12-15s of
+    // silence. If the proxy hangs, fail visibly with stderr rather than
+    // letting the host record an unexplained "transport closed".
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), 15_000);
+    let res;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                bind_secret: opts.bindSecret,
+                public_key_pem: publicKey,
+            }),
+            signal: ac.signal,
+        });
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+            throw new Error("Bind request timed out after 15s — proxy unreachable or slow.");
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
     if (!res.ok) {
         let detail = `HTTP ${res.status}`;
         try {

package/dist/config.js

@@ -20,11 +20,27 @@ const DEFAULT_PROXY_URL = "https://api.agentvalet.ai";
  * then invite-bind. The bind path runs at most once per machine —
  * the secret is consumed after first use.
  */
+// Treat empty strings AND unresolved MCPB template placeholders (e.g.
+// "${user_config.agent_id}") as "not set". Claude Desktop on some platforms
+// passes the literal placeholder through when a user_config field has no
+// value and no manifest default — that would otherwise false-trigger the
+// env-based Path 1 below and skip the invite-bind handshake.
+function envOrNull(name) {
+    const v = process.env[name];
+    if (v === undefined)
+        return null;
+    const t = v.trim();
+    if (t === "")
+        return null;
+    if (t.startsWith("${") && t.endsWith("}"))
+        return null;
+    return t;
+}
 export async function validateConfig() {
     // Path 1 — env-based (legacy).
-    const envAgentId = process.env.AGENT_ID;
-    const envOwnerId = process.env.OWNER_ID;
-    const envProxyUrl = process.env.PROXY_URL;
+    const envAgentId = envOrNull("AGENT_ID");
+    const envOwnerId = envOrNull("OWNER_ID");
+    const envProxyUrl = envOrNull("PROXY_URL");
     if (envAgentId && envOwnerId && envProxyUrl) {
         return buildConfig({
             agentId: envAgentId,
@@ -43,7 +59,7 @@ export async function validateConfig() {
         });
     }
     // Path 3 — first-run invite bind.
-    const inviteBindSecret = process.env.INVITE_BIND_SECRET;
+    const inviteBindSecret = envOrNull("INVITE_BIND_SECRET");
     if (inviteBindSecret) {
         const proxyUrl = (envProxyUrl ?? DEFAULT_PROXY_URL).replace(/\/$/, "");
         process.stderr.write(`[mcp-server] First-run invite bind against ${proxyUrl}…\n`);
@@ -64,16 +80,28 @@ export async function validateConfig() {
             process.exit(1);
         }
     }
-    // Nothing usable — fall through to the original missing-env diagnostic.
+    // Nothing usable — boot credential-less instead of exiting.
+    //
+    // Introspection (initialize + tools/list) must work with NO credentials so
+    // a sandbox (e.g. Glama) can start the server and read the static tool
+    // catalogue. We therefore return a config with an EMPTY identity and a NULL
+    // key rather than process.exit(1). The credential requirement is deferred to
+    // tools/call: an authed tool invoked with no usable identity returns a clean
+    // "credentials not configured" tool result (see index.ts requireCredentials),
+    // never a crash. An empty agentId is the signal for "state C — not configured"
+    // (distinct from "state B — identity present, key pending" which keeps the
+    // existing invite-bind pending response).
     const missing = [];
     for (const key of ["AGENT_ID", "OWNER_ID", "PROXY_URL"]) {
         if (!process.env[key])
             missing.push(key);
     }
-    process.stderr.write(`[mcp-server] Missing required environment variables: ${missing.join(", ")}\n` +
-        `Either set them, run the invite-bind flow with INVITE_BIND_SECRET, ` +
-        `or restore ~/.agentvalet/agent.{key,json} from a previous bind.\n`);
-    process.exit(1);
+    process.stderr.write(`[mcp-server] No credentials configured (${missing.join(", ")} unset, no disk ` +
+        `identity, no INVITE_BIND_SECRET). Booting in introspection-only mode: ` +
+        `tools/list works; tools/call returns a credentials-required message. ` +
+        `Set the env vars, run the invite-bind flow, or restore ` +
+        `~/.agentvalet/agent.{key,json} to enable platform calls.\n`);
+    return buildConfig({ agentId: "", ownerId: "", proxyUrl: DEFAULT_PROXY_URL });
 }
 async function buildConfig(args) {
     const proxyUrl = args.proxyUrl.replace(/\/$/, "");
@@ -90,8 +118,12 @@ async function buildConfig(args) {
             privateKey = await importPKCS8(privateKeyPem, "RS256");
         }
         catch (err) {
-            process.stderr.write(`[mcp-server] Invalid private key: ${err instanceof Error ? err.message : err}\n`);
-            process.exit(1);
+            // Don't crash the process on a malformed key — that would also take down
+            // introspection. Drop the unusable key to null and log; tools/call will
+            // return the credentials-required message instead of a hard exit.
+            process.stderr.write(`[mcp-server] Invalid private key (ignored): ${err instanceof Error ? err.message : err}\n`);
+            privateKeyPem = null;
+            privateKey = null;
         }
     }
     return { agentId: args.agentId, ownerId: args.ownerId, proxyUrl, privateKeyPem, privateKey };

package/dist/index.js

@@ -68,6 +68,40 @@ function pendingFirstCallResponse() {
         isError: true,
     };
 }
+// State C — no credentials at all (empty env / Glama-style sandbox). The
+// server still boots and answers introspection; an authed tool call lands
+// here and gets an actionable message instead of a crash. Distinct from the
+// state-B "owner confirmation pending" response above, which means an identity
+// IS configured but its key hasn't arrived yet.
+function credentialsNotConfiguredResponse() {
+    return {
+        content: [{
+                type: "text",
+                text: "AgentValet credentials are not configured. Set AGENTVALET_AGENT_ID, " +
+                    "AGENTVALET_OWNER_ID, and the agent private key (and optionally " +
+                    "AGENTVALET_PROXY_URL). Run npx @agentvalet/register to create an agent. " +
+                    "Docs: https://github.com/AgentValet/AgentValet#quickstart",
+            }],
+        isError: true,
+    };
+}
+// Credential gate for authed tools/call. Returns null when the call may
+// proceed (state A — a JWT can be signed), or a ready-to-return MCP tool
+// result for the two no-key states:
+//   • state B (identity present, key pending) → existing invite-bind pending
+//     response, preserving the MCPB first-run flow.
+//   • state C (no identity at all)            → credentials-not-configured.
+// The no-auth tools (agent_register / agent_status) intentionally never call
+// this — you must be able to register in order to OBTAIN credentials.
+async function requireCredentials() {
+    if (AGENT_PRIVATE_KEY_RAW !== null)
+        return null;
+    if (AGENT_ID && OWNER_ID) {
+        await notifyBindSecret();
+        return pendingFirstCallResponse();
+    }
+    return credentialsNotConfiguredResponse();
+}
 // ---------------------------------------------------------------------------
 // Tool definitions
 // ---------------------------------------------------------------------------
@@ -499,10 +533,9 @@ function tryParseJson(text) {
 // Tool handlers
 // ---------------------------------------------------------------------------
 async function handleListPlatforms() {
-    if (AGENT_PRIVATE_KEY_RAW === null) {
-        await notifyBindSecret();
-        return pendingFirstCallResponse();
-    }
+    const gate = await requireCredentials();
+    if (gate)
+        return gate;
     let response;
     try {
         response = await fetchWithAuth(`${PROXY_URL}/v1/agent/permissions`, { method: "GET", headers: {} });
@@ -558,10 +591,9 @@ const APPROVAL_POLL_BUDGET_MS = 50_000;
 const APPROVAL_POLL_INTERVAL_MS = 2_000;
 const APPROVAL_PROGRESS_INTERVAL_MS = 5_000;
 async function handleUsePlatform(params, progressToken) {
-    if (AGENT_PRIVATE_KEY_RAW === null) {
-        await notifyBindSecret();
-        return pendingFirstCallResponse();
-    }
+    const gate = await requireCredentials();
+    if (gate)
+        return gate;
     const requestBody = {
         platform: params.platform,
         endpoint: params.endpoint,
@@ -729,6 +761,9 @@ async function handleAgentStatus(token) {
     return jsonContent(body);
 }
 async function handleAuthzenEvaluate(platformId, scope) {
+    const gate = await requireCredentials();
+    if (gate)
+        return gate;
     const authzenBody = {
         subject: { type: "agent", id: AGENT_ID },
         action: { name: "tool_call" },
@@ -750,10 +785,9 @@ async function handleAuthzenEvaluate(platformId, scope) {
     return jsonContent(body);
 }
 async function handleListMyPendingActions() {
-    if (AGENT_PRIVATE_KEY_RAW === null) {
-        await notifyBindSecret();
-        return pendingFirstCallResponse();
-    }
+    const gate = await requireCredentials();
+    if (gate)
+        return gate;
     let response;
     try {
         response = await fetchWithAuth(`${PROXY_URL}/v1/agents/me/pending-actions`, { method: "GET" });
@@ -767,10 +801,9 @@ async function handleListMyPendingActions() {
     return jsonContent(text);
 }
 async function handleReportSelfDiagnostic(args) {
-    if (AGENT_PRIVATE_KEY_RAW === null) {
-        await notifyBindSecret();
-        return pendingFirstCallResponse();
-    }
+    const gate = await requireCredentials();
+    if (gate)
+        return gate;
     // Whitelist body fields — never forward owner_id/agent_id (proxy derives those from JWT).
     const body = {
         severity: args.severity,

package/dist/pem.js

@@ -12,23 +12,39 @@ import { readBoundPrivateKey } from "./bind.js";
  * having pem.ts honour it means subsequent invocations of the
  * mcp-server don't need any env vars at all.
  */
+// Treat empty + unresolved MCPB placeholders ("${user_config.foo}") as
+// not-set — see config.ts for the same defence on identity envs.
+function readEnv(name) {
+    const v = process.env[name];
+    if (v === undefined)
+        return null;
+    const t = v.trim();
+    if (t === "")
+        return null;
+    if (t.startsWith("${") && t.endsWith("}"))
+        return null;
+    return t;
+}
 export function readPrivateKeyFromEnv() {
     // 1. Base64-encoded PEM
-    if (process.env.AGENT_PRIVATE_KEY_B64) {
-        return Buffer.from(process.env.AGENT_PRIVATE_KEY_B64, "base64").toString("utf-8").trim();
+    const b64 = readEnv("AGENT_PRIVATE_KEY_B64");
+    if (b64) {
+        return Buffer.from(b64, "base64").toString("utf-8").trim();
     }
     // 2. Path to PEM file
-    if (process.env.AGENT_PRIVATE_KEY_PATH) {
+    const path = readEnv("AGENT_PRIVATE_KEY_PATH");
+    if (path) {
         try {
-            return readFileSync(process.env.AGENT_PRIVATE_KEY_PATH, "utf-8").trim();
+            return readFileSync(path, "utf-8").trim();
         }
         catch (err) {
             throw new Error(`Cannot read AGENT_PRIVATE_KEY_PATH: ${err instanceof Error ? err.message : err}`);
         }
     }
     // 3. Raw PEM content (multi-line or \n-escaped)
-    if (process.env.AGENT_PRIVATE_KEY) {
-        const raw = process.env.AGENT_PRIVATE_KEY.trim();
+    const rawEnv = readEnv("AGENT_PRIVATE_KEY");
+    if (rawEnv) {
+        const raw = rawEnv;
         // Unescape \n sequences
         const unescaped = raw.replace(/\\n/g, "\n");
         // Wrap bare base64 blob without headers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentvalet/mcp-server",
-  "version": "0.3.9",
+  "version": "1.1.0",
   "description": "AgentValet MCP server — lets AI agents call approved platforms via the AgentValet proxy",
   "type": "module",
   "main": "dist/index.js",