@naumu/mcp 0.7.1 → 0.9.0

package/dist/index.js

@@ -1160,21 +1160,18 @@ function registerReadThread(server2, client2) {
 
 // ../mcp-core/src/tools/whoami.ts
 import { z as z22 } from "zod";
-function registerWhoami(server2, client2, allToolNames) {
+function registerWhoami(server2, client2) {
   server2.registerTool(
     "naumu_whoami",
     {
       title: "Who Am I",
       annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
-      description: 'Return who the calling key is plus the live MCP tool manifest, so you can bootstrap before the first real operation. A bot identity key returns its Identity row (id, graphId, name, instructions, allowedTools). A user API key returns `kind: "user"` with userId, name, and email - a person spans many graphs, so resolve a specific graph via naumu_list_graphs. No arguments. Always available regardless of the permission grid.',
+      description: 'Return who the calling key is, so you can bootstrap before the first real operation. A bot identity key returns its Identity row (id, graphId, name, instructions, allowedTools) plus its curated MCP tool manifest. A user API key returns `kind: "user"` with userId, name, and email - a person spans many graphs, so resolve a specific graph via naumu_list_graphs. The live tool list is already available from tools/list, so it is not repeated here. No arguments. Always available regardless of the permission grid.',
       inputSchema: z22.object({})
     },
     async () => {
       try {
         const data = await client2.get("/api/identities/me/whoami");
-        if (allToolNames && data && typeof data === "object" && data.kind === "user") {
-          data.mcpTools = allToolNames;
-        }
         return {
           content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
         };
@@ -2131,6 +2128,164 @@ function registerChatgptFetch(server2, client2) {
   );
 }
 
+// ../mcp-core/src/tools/admission-status.ts
+import { z as z46 } from "zod";
+function registerAdmissionStatus(server2, client2) {
+  server2.registerTool(
+    "naumu_admission_status",
+    {
+      title: "Admission Status",
+      annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false },
+      description: "Show who can auto-join a Naumu space (graph) and who is waiting for approval: the whitelisted emails (people who join the moment they sign in with that email), the auto-join domain wildcards, and the count of pending join requests. When there are pending requests, this also returns the full list (who requested, their email, git-email hint, and message) so you can act on them with naumu_resolve_join_request. Use it during repo init to review or seed access, or whenever the user asks who has access to a space or who is asking to join.",
+      inputSchema: z46.object({
+        graphId: z46.string().describe("The space (graph) ID to inspect admission for. You must be a member of this space.")
+      })
+    },
+    async ({ graphId }) => {
+      try {
+        const status = await client2.get(
+          `/api/graphs/${graphId}/admission`
+        );
+        let pendingRequests;
+        if (status && status.pendingRequestCount > 0) {
+          pendingRequests = await client2.get(
+            `/api/graphs/${graphId}/admission/requests?status=pending`
+          );
+        }
+        const result = { ...status, pendingRequests };
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/whitelist-members.ts
+import { z as z47 } from "zod";
+function registerWhitelistMembers(server2, client2) {
+  server2.registerTool(
+    "naumu_whitelist_members",
+    {
+      title: "Whitelist Members",
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      description: "Whitelist emails so those people auto-join a Naumu space (graph) the moment they sign in with that email. Use this during repo init: after you scrub git history, present the curated list of collaborators to the user, and get their explicit confirmation, call this with the confirmed emails. It is silent - it sends no invite emails, it just pre-authorizes those addresses. Returns which entries were created and which were skipped (already whitelisted or already members). Set repoInit true when this call is part of the repo init flow.",
+      inputSchema: z47.object({
+        graphId: z47.string().describe("The space (graph) ID to whitelist emails for. You must be a member of this space."),
+        emails: z47.array(z47.string()).min(1).describe("The emails to whitelist. Each becomes an exact-match auto-join entry. Present these to the user and get confirmation before calling."),
+        repoInit: z47.boolean().optional().describe("Set true when this whitelist is being seeded as part of the repo init flow, so onboarding is tracked correctly.")
+      })
+    },
+    async ({ graphId, emails, repoInit }) => {
+      try {
+        const result = await client2.post(`/api/graphs/${graphId}/admission/whitelist`, {
+          entries: emails.map((email) => ({ email })),
+          repoInit
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/resolve-admission.ts
+import { z as z48 } from "zod";
+function registerResolveAdmission(server2, client2) {
+  server2.registerTool(
+    "naumu_resolve_admission",
+    {
+      title: "Resolve Admission",
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      description: "The call a coding agent makes right after connecting when a repo's .naumu references a space the user is not yet a member of. It evaluates whether the user can join and does it: outcome is joined-whitelist or joined-wildcard (the user is now a member - proceed), already-member (nothing to do), request-created (a join request was just filed and is awaiting a member's approval), or request-pending (a request was already open). When the response also carries reason 'seat-limit' on a request-created/request-pending outcome, the user WOULD have auto-joined via a whitelist/domain match but the space is at its seat limit - so their access is pending an admin approving them or upgrading the plan; relay that specific reason honestly, do not just say 'no match'. Pass gitEmailHint from `git config user.email` so a matching whitelist or domain rule can admit them. Relay the outcome to the user honestly: say plainly whether they joined or are waiting for approval - never imply access that is still pending.",
+      inputSchema: z48.object({
+        graphId: z48.string().describe("The space (graph) ID referenced by the repo .naumu file that the user wants to join."),
+        gitEmailHint: z48.string().optional().describe("The email from `git config user.email`, used to match whitelist entries and auto-join domains.")
+      })
+    },
+    async ({ graphId, gitEmailHint }) => {
+      try {
+        const result = await client2.post("/api/admission/resolve", {
+          graphId,
+          gitEmailHint
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// ../mcp-core/src/tools/resolve-join-request.ts
+import { z as z49 } from "zod";
+function registerResolveJoinRequest(server2, client2) {
+  server2.registerTool(
+    "naumu_resolve_join_request",
+    {
+      title: "Resolve Join Request",
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      },
+      description: "For a member resolving a pending join request surfaced by naumu_admission_status. Approve to add the requester to the space as a member, or deny to reject the request. Get the requestId from naumu_admission_status's pending list, and confirm the decision with the user before calling since approving grants access.",
+      inputSchema: z49.object({
+        graphId: z49.string().describe("The space (graph) ID the request is for. You must be a member of this space."),
+        requestId: z49.string().describe("The pending join request ID, taken from naumu_admission_status."),
+        action: z49.enum(["approve", "deny"]).describe("approve adds the requester as a member; deny rejects the request.")
+      })
+    },
+    async ({ graphId, requestId, action }) => {
+      try {
+        const result = await client2.post(
+          `/api/graphs/${graphId}/admission/requests/${requestId}/resolve`,
+          { action }
+        );
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // ../mcp-core/src/tools/index.ts
 var TOOL_REGISTRARS = {
   naumu_list_graphs: registerListGraphs,
@@ -2182,7 +2337,14 @@ var TOOL_REGISTRARS = {
   // search + node read and emit the `{ results }` / `{ id, title, text, url }`
   // shapes that client expects (see chatgpt-search.ts / chatgpt-fetch.ts).
   search: registerChatgptSearch,
-  fetch: registerChatgptFetch
+  fetch: registerChatgptFetch,
+  // Admission / onboarding-wedge tools (user-surface only — omitted from
+  // BOT_ONLY_TOOL_NAMES and from the backend PERMISSION_TO_MCP_TOOLS map, so
+  // bots never receive them, matching the naumu_list_graphs precedent).
+  naumu_admission_status: registerAdmissionStatus,
+  naumu_whitelist_members: registerWhitelistMembers,
+  naumu_resolve_admission: registerResolveAdmission,
+  naumu_resolve_join_request: registerResolveJoinRequest
 };
 var BOT_ONLY_TOOL_NAMES = /* @__PURE__ */ new Set(["naumu_create_thread"]);
 var ALL_TOOL_NAMES = Object.keys(TOOL_REGISTRARS).filter(
@@ -2191,11 +2353,7 @@ var ALL_TOOL_NAMES = Object.keys(TOOL_REGISTRARS).filter(
 function registerAllTools(server2, client2) {
   for (const [name, registrar] of Object.entries(TOOL_REGISTRARS)) {
     if (BOT_ONLY_TOOL_NAMES.has(name)) continue;
-    if (name === "naumu_whoami") {
-      registerWhoami(server2, client2, ALL_TOOL_NAMES);
-    } else {
-      registrar(server2, client2);
-    }
+    registrar(server2, client2);
   }
 }
 function registerNamedTools(server2, client2, toolNames) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@naumu/mcp",
-	"version": "0.7.1",
+	"version": "0.9.0",
 	"description": "MCP server for Naumu – access your knowledge graph from Claude Code, Cursor, and other AI coding agents",
 	"license": "MIT",
 	"author": "Naumu <hello@naumu.ai>",