@pikku/inspector 0.12.83 → 0.12.85

package/CHANGELOG.md

@@ -1,3 +1,40 @@
+## 0.12.85
+
+### Patch Changes
+
+- b312867: A project can now serve several MCP endpoints, one per connector.
+
+  Until now every MCP tool in a project was pooled onto a single `/mcp`, so a hub offering three connectors offered one endpoint listing all three connectors' tools at once. A client pointed at it saw tools it had no business calling, and the only way to give a connector an endpoint of its own was to give it a deployment of its own — three deploys, three bills, three service graphs.
+
+  `wireAddon` gains `mcpEndpoint`. `true` serves that instance's tools at `/mcp/<name>`; a string is the path, used as given. Leaving it unset keeps the tools on the shared endpoint, which is where they have always been, so nothing existing moves.
+
+  A surfaced instance now gets its own manifest (`.pikku/mcp/mcp.<name>.gen.json`, carrying the path it answers on), its own deploy unit (`mcp-<name>`, routed on that path), and its own MCP server — with its own tool list, so a client pointed at one endpoint never sees another's tools. The plumbing for the per-surface manifest and unit already existed in `deploy apply`; nothing had ever produced one.
+
+  `pikku dev` mounts every endpoint the generated tree describes, not just the default one. Without that a project that moved its tools onto their own endpoints would have served nothing locally at all — the default manifest it reads is empty precisely because they moved — and the only way to try a connector would have been to deploy it.
+
+  The node and bun transports take `mcpSurfaces` alongside `mcpJson` and mount each at its own path, longest path first. `/mcp` claims everything beneath `/mcp/`, so without that ordering the default endpoint answers `/mcp/weather` and the surface's tools are unreachable.
+
+  OAuth discovery is split between the endpoints rather than duplicated across them. RFC 9728 folds a resource's path into its well-known route, so each endpoint's own document is already distinct, but the path-less `/.well-known/oauth-protected-resource` predates that and describes whichever resource answers it. Only the default endpoint claims it — otherwise every unit registers the same route and the provider's router decides which resource a client is told about, and in dev a client probing it is described whichever surface sorted first.
+
+- Updated dependencies [87971bd]
+- Updated dependencies [b312867]
+- Updated dependencies [51bd35a]
+  - @pikku/core@0.12.116
+
+## 0.12.84
+
+### Patch Changes
+
+- 238902c: A channel's `auth` flag now reaches its meta. The inspector already read it to mark the connect and disconnect functions sessionless, then dropped it, so nothing downstream could tell a public channel from a private one without reading the generated source.
+
+  That matters in front of the channel rather than inside it. A `wireCLI({ auth: false })` program is reachable by anyone holding its address; a router or deploy that cannot see the flag either guesses or demands a token in front of a surface it was never protecting, locking out the clients the program was opened for.
+
+  The flag is only recorded when the channel actually said. A channel that never mentioned `auth` leaves it absent rather than claiming a default it did not declare, which the runtime continues to read as requiring a session.
+
+- Updated dependencies [238902c]
+- Updated dependencies [2fd2b22]
+  - @pikku/core@0.12.115
+
 ## 0.12.83
 
 ### Patch Changes

package/dist/add/add-channel.js

@@ -482,8 +482,9 @@ export const addChannel = (logger, node, checker, state, options) => {
     // with pikkuChannelConnectionFunc/pikkuChannelDisconnectionFunc (not pikkuFunc/
     // pikkuSessionlessFunc), so the runtime has correct sessionless info without
     // needing to inject it at runtime.
+    const channelAuth = getPropertyValue(obj, 'auth');
     {
-        const routeAuth = getPropertyValue(obj, 'auth');
+        const routeAuth = channelAuth;
         const sessionless = routeAuth === false ? true : undefined;
         for (const funcId of [connectFuncId, disconnectFuncId]) {
             if (funcId && !state.functions.meta[funcId]) {
@@ -538,6 +539,11 @@ export const addChannel = (logger, node, checker, state, options) => {
         message,
         messageWirings,
         binary: binary === undefined ? undefined : binary,
+        // Recorded so a deploy can tell a public surface from a private one without
+        // reading the generated source. Only stored when the channel actually said,
+        // so a channel that never mentioned auth stays absent rather than claiming
+        // a default it did not declare.
+        auth: typeof channelAuth === 'boolean' ? channelAuth : undefined,
         summary,
         description,
         errors,

package/dist/add/add-wire-addon.js

@@ -95,6 +95,7 @@ export function addWireAddon(node, state, logger) {
     let pkg;
     let rpcEndpoint;
     let mcp;
+    let mcpEndpoint;
     let auth;
     let tags;
     let scopes;
@@ -125,6 +126,15 @@ export function addWireAddon(node, state, logger) {
                     ? prop.initializer.kind === ts.SyntaxKind.TrueKeyword
                     : parseStringArray(prop.initializer);
         }
+        else if (key === 'mcpEndpoint') {
+            if (ts.isStringLiteral(prop.initializer)) {
+                mcpEndpoint = prop.initializer.text;
+            }
+            else if (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
+                prop.initializer.kind === ts.SyntaxKind.FalseKeyword) {
+                mcpEndpoint = prop.initializer.kind === ts.SyntaxKind.TrueKeyword;
+            }
+        }
         else if (key === 'auth' &&
             (prop.initializer.kind === ts.SyntaxKind.TrueKeyword ||
                 prop.initializer.kind === ts.SyntaxKind.FalseKeyword)) {
@@ -175,6 +185,7 @@ export function addWireAddon(node, state, logger) {
         file: node.getSourceFile().fileName,
         rpcEndpoint,
         mcp,
+        mcpEndpoint,
         auth,
         tags,
         scopes,

package/dist/inspector.js

@@ -115,6 +115,7 @@ export function getInitialInspectorState(rootDir) {
             toolsMeta: {},
             promptsMeta: {},
             files: new Set(),
+            surfaces: {},
         },
         agents: {
             agentsMeta: {},

package/dist/types.d.ts

@@ -589,6 +589,13 @@ export interface InspectorState {
              * when the declared value was not a statically-knowable literal.
              */
             mcp?: boolean | string[];
+            /**
+             * Serves this instance's MCP tools on an endpoint of their own rather
+             * than the project's default one. `true` means `/mcp/<name>`; a string
+             * is the path as given. Absent leaves the tools on the default
+             * endpoint, which is where they have always been.
+             */
+            mcpEndpoint?: boolean | string;
             /**
              * The addon's own gates. `runPikkuFunc` applies these to every function
              * in the package, on every wiring path — not just `namespace:function`.
@@ -631,6 +638,12 @@ export interface InspectorState {
         toolsMeta: MCPToolMeta;
         promptsMeta: MCPPromptMeta;
         files: Set<string>;
+        /**
+         * Every MCP endpoint the project serves beyond the default one, as
+         * surface name -> the path it is served on. A meta entry carrying a
+         * `surface` is served by the endpoint named here and by no other.
+         */
+        surfaces: Record<string, string>;
     };
     agents: {
         agentsMeta: AgentsMeta;

package/dist/utils/load-addon-functions-meta.js

@@ -153,6 +153,17 @@ export async function loadAddonFunctionsMeta(logger, state) {
             // decides which of the addon's functions a model gets to see.
             if (decl.mcp) {
                 const selected = Array.isArray(decl.mcp) ? new Set(decl.mcp) : null;
+                // `mcpEndpoint` gives this instance an endpoint to itself, which is
+                // what lets one project expose several connectors: a client pointed at
+                // one surface lists that surface's tools and no others. Unset keeps
+                // the tools on the project's single endpoint.
+                const surface = decl.mcpEndpoint ? namespace : undefined;
+                if (surface) {
+                    state.mcpEndpoints.surfaces[surface] =
+                        typeof decl.mcpEndpoint === 'string'
+                            ? decl.mcpEndpoint
+                            : `/mcp/${namespace}`;
+                }
                 for (const [funcName, funcMeta] of Object.entries(meta)) {
                     if (selected ? !selected.has(funcName) : !funcMeta.mcp) {
                         continue;
@@ -165,6 +176,7 @@ export async function loadAddonFunctionsMeta(logger, state) {
                         inputSchema: funcMeta.inputSchemaName ?? null,
                         outputSchema: funcMeta.outputSchemaName ?? null,
                         tags: funcMeta.tags,
+                        ...(surface ? { surface } : {}),
                     };
                 }
                 // A name the addon does not publish is a tool the app believes it

package/dist/utils/serialize-inspector-state.d.ts

@@ -212,6 +212,7 @@ export interface SerializableInspectorState {
         toolsMeta: InspectorState['mcpEndpoints']['toolsMeta'];
         promptsMeta: InspectorState['mcpEndpoints']['promptsMeta'];
         files: string[];
+        surfaces?: InspectorState['mcpEndpoints']['surfaces'];
     };
     agents: {
         invokedAgentsByFile?: Array<[string, string[]]>;

package/dist/utils/serialize-inspector-state.js

@@ -92,6 +92,7 @@ export function serializeInspectorState(state) {
             toolsMeta: state.mcpEndpoints.toolsMeta,
             promptsMeta: state.mcpEndpoints.promptsMeta,
             files: Array.from(state.mcpEndpoints.files),
+            surfaces: state.mcpEndpoints.surfaces,
         },
         agents: {
             agentsMeta: state.agents?.agentsMeta ?? {},
@@ -278,6 +279,7 @@ export function deserializeInspectorState(data) {
             toolsMeta: data.mcpEndpoints.toolsMeta,
             promptsMeta: data.mcpEndpoints.promptsMeta,
             files: new Set(data.mcpEndpoints.files),
+            surfaces: data.mcpEndpoints.surfaces ?? {},
         },
         agents: {
             agentsMeta: data.agents?.agentsMeta || {},

package/dist/utils/serialize-mcp-json.d.ts

@@ -1,2 +1,10 @@
 import type { InspectorLogger, InspectorState } from '../types.js';
-export declare const serializeMCPJson: (logger: InspectorLogger, state: InspectorState) => string;
+/**
+ * Serializes one MCP endpoint's manifest.
+ *
+ * A project can serve several endpoints, and a wiring belongs to exactly one of
+ * them: the one named by its `surface`. Passing no surface serializes the
+ * default endpoint, which is every wiring that named none — so a project with
+ * no surfaces at all gets the single manifest it always got.
+ */
+export declare const serializeMCPJson: (logger: InspectorLogger, state: InspectorState, surface?: string) => string;

package/dist/utils/serialize-mcp-json.js

@@ -1,8 +1,17 @@
 import { resolveFunctionMeta } from './resolve-function-meta.js';
-export const serializeMCPJson = (logger, state) => {
+/**
+ * Serializes one MCP endpoint's manifest.
+ *
+ * A project can serve several endpoints, and a wiring belongs to exactly one of
+ * them: the one named by its `surface`. Passing no surface serializes the
+ * default endpoint, which is every wiring that named none — so a project with
+ * no surfaces at all gets the single manifest it always got.
+ */
+export const serializeMCPJson = (logger, state, surface) => {
     const { mcpEndpoints, functions, schemas } = state;
     const { typesMap } = functions;
     const { resourcesMeta, toolsMeta, promptsMeta } = mcpEndpoints;
+    const onThisSurface = (meta) => (meta.surface ?? undefined) === surface;
     const tools = [];
     const resources = [];
     const prompts = [];
@@ -37,6 +46,8 @@ export const serializeMCPJson = (logger, state) => {
         return schema;
     };
     for (const [name, endpointMeta] of Object.entries(resourcesMeta)) {
+        if (!onThisSurface(endpointMeta))
+            continue;
         const functionMeta = resolveFunctionMeta(state, endpointMeta.pikkuFuncId);
         if (!functionMeta) {
             logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping resource ${name}.`);
@@ -56,6 +67,8 @@ export const serializeMCPJson = (logger, state) => {
         });
     }
     for (const [name, endpointMeta] of Object.entries(toolsMeta)) {
+        if (!onThisSurface(endpointMeta))
+            continue;
         const functionMeta = resolveFunctionMeta(state, endpointMeta.pikkuFuncId);
         if (!functionMeta) {
             logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping tool ${name}.`);
@@ -74,6 +87,8 @@ export const serializeMCPJson = (logger, state) => {
         });
     }
     for (const [name, endpointMeta] of Object.entries(promptsMeta)) {
+        if (!onThisSurface(endpointMeta))
+            continue;
         const functionMeta = resolveFunctionMeta(state, endpointMeta.pikkuFuncId);
         if (!functionMeta) {
             logger.warn(`Function ${endpointMeta.pikkuFuncId} not found in functionsMeta. Skipping prompt ${name}.`);
@@ -101,5 +116,9 @@ export const serializeMCPJson = (logger, state) => {
             arguments: argumentsArray,
         });
     }
-    return JSON.stringify({ tools, resources, prompts }, null, 2);
+    // The path only travels in a surface's own manifest: the default endpoint
+    // stays at whatever the runtime mounts, which is what every existing project
+    // already relies on.
+    const mcpPath = surface ? mcpEndpoints.surfaces?.[surface] : undefined;
+    return JSON.stringify({ ...(mcpPath ? { mcpPath } : {}), tools, resources, prompts }, null, 2);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/inspector",
-  "version": "0.12.83",
+  "version": "0.12.85",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/pikkujs/pikku.git",
@@ -55,10 +55,10 @@
     "zod-to-ts": "^2.1.0"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.114"
+    "@pikku/core": "^0.12.116"
   },
   "devDependencies": {
-    "@pikku/core": "^0.12.114",
+    "@pikku/core": "^0.12.116",
     "@types/node": "^24.13.3"
   },
   "engines": {