pombus 0.1.7 → 0.1.8

package/README.md

@@ -50,6 +50,10 @@ Set `POMBUS_API_KEY` in the environment. `init` writes it into the MCP server
 block for you; the key never lands in your terminal scrollback. Get a key at
 [pombus.com](https://pombus.com).
 
+Without a key, `pombus mcp` still starts, for introspection only: it lists the
+tool catalog, and every tool call returns a "POMBUS_API_KEY is not set" error.
+It makes no network request until a key is set.
+
 ```json
 {
   "mcpServers": {

package/dist/i18n.js

@@ -12,7 +12,9 @@ const LOCALES = ["en-US", "pt-BR", "es-419"];
 // Codes that only ever reach the MODEL (inside a tool call) are NOT human i18n — they stay en-US
 // protocol text in server.ts (`error: <code>`), never in this dict.
 // Boot-reachable codes (path 1):
-//   - no_api_key: the key env var is unset (server.ts, before any request).
+//   - no_api_key: the key env var is unset (server.ts, before any request). Also the text of every
+//     tool call on a keyless server — the one human message that reaches the model, because only the
+//     human can fix it.
 //   - auth_failed: /v0/auth/me rejected the key at boot (invalid/expired).
 //   - network:    the core was unreachable at boot.
 //   - unknown:    the last-resort fallback for a boot error with no mapped code (bin.ts catch).

package/dist/scope.js

@@ -76,6 +76,12 @@ export class ScopeBinding {
         // domain / pod / organization: no single implied inbox.
         return new ScopeBinding(me.scope_type, null, permissions, podId);
     }
+    /** The binding of a server started WITHOUT a key (stdio introspection): shaped like an org master key
+     *  so the catalog lists every tool with its generic schema. It never reaches a request — the keyless
+     *  server refuses every call before dispatch (server.ts keylessServer). */
+    static unbound() {
+        return new ScopeBinding("organization", null, null, null);
+    }
     /** Record inbox ids returned by list_inboxes so later calls can validate against the enumeration. */
     remember(ids) {
         for (const id of ids)

package/dist/server.js

@@ -13,17 +13,18 @@ import { CoreClient, CoreError, readApiKey } from "./client.js";
 import { ScopeBinding, ScopeError } from "./scope.js";
 import { specByName, toolDescriptors, callTool, callOrgTool, isOrgTool, ToolArgError, } from "./tools.js";
 const SERVER_NAME = "pombus";
-const SERVER_VERSION = "0.1.7";
-/** Build and connect the MCP server over stdio. Fails fast (before connecting) when the key is absent,
- *  so a misconfigured client sees a clear stderr line instead of a server that answers every tool with
- *  an auth error. */
+const SERVER_VERSION = "0.1.8";
+/** Build and connect the MCP server over stdio. Without a key the server still comes up for
+ *  introspection (registries such as Glama boot it with no credential to read the catalog): it lists
+ *  every tool and answers every call with the localized "set POMBUS_API_KEY" error, making no network
+ *  call. A key that IS set but rejected still fails fast at boot — that is a config error to surface. */
 export async function runMcpServer() {
     const { humanMessage, humanCodeForBoot } = await import("./i18n.js");
     const apiKey = readApiKey();
     if (!apiKey) {
         // Human-facing, localized, to stderr — never stdout (would corrupt the MCP stream).
         process.stderr.write(humanMessage("no_api_key") + "\n");
-        process.exitCode = 1;
+        await (await buildServer(null)).connect(new StdioServerTransport());
         return;
     }
     const client = new CoreClient({ apiKey });
@@ -46,16 +47,37 @@ export async function runMcpServer() {
 }
 /** Build the Server bound to a given core client. Exposed so tests drive it with a fake core and
  *  without a real stdio transport. Resolves the key's scope up front (one /v0/auth/me call) so the
- *  tool schemas can omit inbox_id for a single-inbox key. */
+ *  tool schemas can omit inbox_id for a single-inbox key. `null` = no key (stdio introspection only):
+ *  the full catalog is listed and every call is refused before any request could exist. */
 export async function buildServer(client, opts = {}) {
-    const scope = await ScopeBinding.resolve(client);
+    if (client === null)
+        return keylessServer();
+    return boundServer(client, await ScopeBinding.resolve(client), opts);
+}
+/** No key: list the whole catalog (an org master binding — every tool, generic schemas) and refuse
+ *  every call with the localized no_api_key line, so the model can tell the human what to configure.
+ *  Localized on purpose (unlike the en-US `error: <code>` protocol text): the fix is the human's. */
+function keylessServer() {
+    const scope = ScopeBinding.unbound();
+    const server = newServer();
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: toolDescriptors(scope) }));
+    server.setRequestHandler(CallToolRequestSchema, async () => {
+        const { humanMessage } = await import("./i18n.js");
+        return toolError(humanMessage("no_api_key"));
+    });
+    return server;
+}
+function newServer() {
+    return new Server({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} } });
+}
+function boundServer(client, scope, opts) {
     const orgTools = opts.orgSession !== undefined;
     const ctx = {
         client,
         scope,
         ...(opts.orgSession !== undefined ? { orgSession: opts.orgSession } : {}),
     };
-    const server = new Server({ name: SERVER_NAME, version: SERVER_VERSION }, { capabilities: { tools: {} } });
+    const server = newServer();
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: toolDescriptors(scope, { orgTools }),
     }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pombus",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Pombus MCP server — email boxes for AI agents. A thin stdio translator between MCP tool calls and the Pombus REST core.",
   "license": "MIT",
   "author": "Runaki",