@agentvalet/mcp-server 0.3.10 → 1.1.0

package/dist/config.js

@@ -80,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(/\/$/, "");
@@ -106,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/package.json

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