backlog-mcp-server 0.9.1 → 0.11.0

package/README.ja.md

@@ -507,6 +507,93 @@ npm test
 node build/index.js --optimize-response --max-tokens=100000 --prefix="backlog_" --enable-toolsets space,issue
 ```
 
+## 複数組織対応
+
+このサーバーは、1つのMCPサーバーインスタンスから複数のBacklog組織にアクセスできるよう設定できます。
+
+### 設定
+
+組織ごとに環境変数のペアを定義し、デフォルト組織を設定します。
+
+```bash
+BACKLOG_DEFAULT_ORG=COMPANY_A
+BACKLOG_ORG_COMPANY_A_DOMAIN=company-a.backlog.com
+BACKLOG_ORG_COMPANY_A_API_KEY=your-company-a-api-key
+BACKLOG_ORG_COMPANY_B_DOMAIN=company-b.backlog.com
+BACKLOG_ORG_COMPANY_B_API_KEY=your-company-b-api-key
+```
+
+これらの変数は、ローカルの`.env`、シェル環境変数、またはMCPクライアント設定の`env`ブロックのいずれからでも利用できます。
+
+MCP設定例：
+
+```json
+{
+  "mcpServers": {
+    "backlog": {
+      "env": {
+        "BACKLOG_DEFAULT_ORG": "COMPANY_A",
+        "BACKLOG_ORG_COMPANY_A_DOMAIN": "company-a.backlog.com",
+        "BACKLOG_ORG_COMPANY_A_API_KEY": "your-company-a-api-key",
+        "BACKLOG_ORG_COMPANY_B_DOMAIN": "company-b.backlog.com",
+        "BACKLOG_ORG_COMPANY_B_API_KEY": "your-company-b-api-key"
+      }
+    }
+  }
+}
+```
+
+複数組織用の環境変数が設定されていない場合、サーバーは従来どおり単一組織用の設定にフォールバックします。
+
+```bash
+BACKLOG_DOMAIN=your-domain.backlog.com
+BACKLOG_API_KEY=your-api-key
+```
+
+### ツールの使い方
+
+通常のツールはすべて、任意の`organization`入力フィールドを受け付けます。指定した場合、そのBacklog組織に対してツールが実行されます。
+
+例：
+
+```json
+{
+  "organization": "COMPANY_B",
+  "projectKey": "PROJECT"
+}
+```
+
+`organization`を省略した場合：
+
+- `BACKLOG_DEFAULT_ORG`で指定した組織が使われます
+- 複数組織用の環境変数が存在するのに`BACKLOG_DEFAULT_ORG`が未設定の場合、サーバーは起動時に失敗します
+
+### 組織一覧の確認
+
+サーバーは `list_organizations` ツールを提供しており、設定済みの組織名、ドメイン、デフォルト組織かどうかを返します。
+
+レスポンス例：
+
+```json
+[
+  {
+    "name": "COMPANY_A",
+    "domain": "company-a.backlog.com",
+    "isDefault": true
+  },
+  {
+    "name": "COMPANY_B",
+    "domain": "company-b.backlog.com",
+    "isDefault": false
+  }
+]
+```
+
+### 注意
+
+- 複数組織モードでは、各組織に対して `BACKLOG_ORG_<NAME>_DOMAIN` と `BACKLOG_ORG_<NAME>_API_KEY` の両方を定義する必要があります
+- `<NAME>` の部分が、`organization`入力や `list_organizations` に表示される組織名になります
+
 ## ライセンス
 
 このプロジェクトは [MITライセンス](./LICENSE) のもとでライセンスされています。

package/README.md

@@ -139,6 +139,30 @@ npm run dev
 }
 ```
 
+### HTTP transport (Streamable HTTP)
+
+By default the server uses **stdio**. To run the [MCP Streamable HTTP](https://modelcontextprotocol.io/) transport instead (JSON-RPC over HTTP, same tools as stdio), start with `--transport http` or set `MCP_TRANSPORT=http`.
+
+```bash
+npm run build
+MCP_TRANSPORT=http MCP_HTTP_PORT=3333 node build/index.js
+```
+
+- **Endpoint:** `POST`, `GET`, and `DELETE` on `http://<host>:<port><path>` (default path `/mcp`).
+- **Session:** After `initialize`, clients must send the `mcp-session-id` header on later requests (as returned by the server).
+- **Security:** Default bind is `127.0.0.1`. Do not expose the HTTP port to untrusted networks without authentication and TLS; it allows full use of your Backlog API key via MCP tools.
+
+Environment variables (CLI flags override when both are set):
+
+| Variable | Description |
+| -------- | ----------- |
+| `MCP_TRANSPORT` | `stdio` (default) or `http` |
+| `MCP_HTTP_HOST` | Bind address (default `127.0.0.1`) |
+| `MCP_HTTP_PORT` | Port (default `3333`) |
+| `MCP_HTTP_PATH` | URL path (default `/mcp`) |
+| `MCP_HTTP_JSON_RESPONSE` | `true` to prefer JSON responses over SSE when supported |
+| `MCP_HTTP_ALLOWED_HOSTS` | Comma-separated allowed `Host` values when binding to `0.0.0.0` (DNS rebinding protection) |
+
 ## Tool Configuration
 
 You can selectively enable or disable specific **toolsets** using the `--enable-toolsets` command-line flag or the `ENABLE_TOOLSETS` environment variable. This allows better control over which tools are available to the AI agent and helps reduce context size.
@@ -573,6 +597,10 @@ npm test
 
 The server supports several command line options:
 
+- `--transport stdio|http`: MCP transport (default: stdio). Use `http` for Streamable HTTP.
+- `--http-host`, `--http-port`, `--http-path`: HTTP bind address, port, and path (defaults: `127.0.0.1`, `3333`, `/mcp`).
+- `--http-json-response`: Prefer JSON responses over SSE when the transport supports it.
+- `--http-allowed-hosts`: Comma-separated allowed `Host` headers when binding to all interfaces.
 - `--export-translations`: Export all translation keys and values
 - `--optimize-response`: Enable GraphQL-style field selection
 - `--max-tokens=NUMBER`: Set maximum token limit for responses
@@ -587,6 +615,95 @@ Example:
 node build/index.js --optimize-response --max-tokens=100000 --prefix="backlog_" --enable-toolsets space,issue
 ```
 
+HTTP example:
+
+```bash
+node build/index.js --transport http --http-port 3333 --http-path /mcp
+```
+
+## Multi-Organization Support
+
+This server can be configured to access multiple Backlog organizations from a single MCP server instance.
+
+### Configuration
+
+Configure one env pair per organization and set a default organization:
+
+```bash
+BACKLOG_DEFAULT_ORG=COMPANY_A
+BACKLOG_ORG_COMPANY_A_DOMAIN=company-a.backlog.com
+BACKLOG_ORG_COMPANY_A_API_KEY=your-company-a-api-key
+BACKLOG_ORG_COMPANY_B_DOMAIN=company-b.backlog.com
+BACKLOG_ORG_COMPANY_B_API_KEY=your-company-b-api-key
+```
+
+This works whether the variables come from a local `.env`, your shell environment, or an MCP client config `env` block.
+
+Example MCP config:
+
+```json
+{
+  "env": {
+    "BACKLOG_DEFAULT_ORG": "COMPANY_A",
+    "BACKLOG_ORG_COMPANY_A_DOMAIN": "company-a.backlog.com",
+    "BACKLOG_ORG_COMPANY_A_API_KEY": "your-company-a-api-key",
+    "BACKLOG_ORG_COMPANY_B_DOMAIN": "company-b.backlog.com",
+    "BACKLOG_ORG_COMPANY_B_API_KEY": "your-company-b-api-key"
+  }
+}
+```
+
+If no multi-organization env vars are set, the server falls back to the existing single-organization configuration:
+
+```bash
+BACKLOG_DOMAIN=your-domain.backlog.com
+BACKLOG_API_KEY=your-api-key
+```
+
+### Tool Usage
+
+All normal tools accept an optional `organization` input field. When provided, the tool call is routed to that Backlog organization.
+
+Examples:
+
+```json
+{
+  "organization": "COMPANY_B",
+  "projectKey": "PROJECT"
+}
+```
+
+If `organization` is omitted:
+
+- the organization named by `BACKLOG_DEFAULT_ORG` is used
+- if multi-organization env vars are present and `BACKLOG_DEFAULT_ORG` is missing, the server fails at startup
+
+### Organization Discovery
+
+The server provides a `list_organizations` tool that returns the configured organization names, their domains, and which one is the default.
+
+Example response:
+
+```json
+[
+  {
+    "name": "COMPANY_A",
+    "domain": "company-a.backlog.com",
+    "isDefault": true
+  },
+  {
+    "name": "COMPANY_B",
+    "domain": "company-b.backlog.com",
+    "isDefault": false
+  }
+]
+```
+
+### Notes
+
+- For multi-org mode, every organization must define both `BACKLOG_ORG_<NAME>_DOMAIN` and `BACKLOG_ORG_<NAME>_API_KEY`.
+- The `<NAME>` part is the organization name exposed through the `organization` tool input and `list_organizations`.
+
 ## License
 
 This project is licensed under the [MIT License](./LICENSE).

package/build/createBacklogMcpServer.js

@@ -0,0 +1,29 @@
+// Copyright (c) 2025 Nulab inc.
+// Licensed under the MIT License.
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerDynamicTools, registerTools } from './registerTools.js';
+import { organizationTools } from './tools/dynamicTools/organizations.js';
+import { dynamicTools } from './tools/dynamicTools/toolsets.js';
+import { createToolRegistrar } from './utils/toolRegistrar.js';
+import { buildToolsetGroup } from './utils/toolsetUtils.js';
+import { wrapServerWithToolRegistry, } from './utils/wrapServerWithToolRegistry.js';
+/**
+ * Builds a fresh MCP server instance with all Backlog tools registered.
+ * Used once for stdio; one instance per HTTP session for Streamable HTTP.
+ */
+export function createBacklogMcpServer({ version, useFields, backlog, clientRegistry, transHelper, enabledToolsets, mcpOption, dynamicToolsets, }) {
+    const server = wrapServerWithToolRegistry(new McpServer({
+        name: 'backlog',
+        title: useFields ? 'backlog (field selection enabled)' : 'backlog',
+        version,
+    }));
+    const toolsetGroup = buildToolsetGroup(backlog, transHelper, enabledToolsets);
+    registerTools(server, toolsetGroup, mcpOption);
+    registerDynamicTools(server, organizationTools(clientRegistry, transHelper), mcpOption.prefix);
+    if (dynamicToolsets) {
+        const registrar = createToolRegistrar(server, toolsetGroup, mcpOption);
+        const dynamicToolsetGroup = dynamicTools(registrar, transHelper, toolsetGroup);
+        registerDynamicTools(server, dynamicToolsetGroup, mcpOption.prefix);
+    }
+    return server;
+}

package/build/handlers/builders/composeToolHandler.js

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { wrapWithErrorHandling } from '../transformers/wrapWithErrorHandling.js';
 import { wrapWithFieldPicking } from '../transformers/wrapWithFieldPicking.js';
+import { wrapWithOrganizationContext } from '../transformers/wrapWithOrganizationContext.js';
 import { wrapWithTokenLimit } from '../transformers/wrapWithTokenLimit.js';
 import { wrapWithToolResult } from '../transformers/wrapWithToolResult.js';
 import { z } from 'zod';
@@ -8,19 +9,26 @@ import { generateFieldsDescription } from '../../utils/generateFieldsDescription
 export function composeToolHandler(tool, options) {
     const { useFields, errorHandler, maxTokens } = options;
     // Step 1: Add `fields` to schema if needed
-    if (useFields) {
-        const fieldDesc = generateFieldsDescription(tool.outputSchema, tool.importantFields ?? [], tool.name);
-        tool.schema = extendSchema(tool.schema, fieldDesc);
-    }
+    const fieldDesc = useFields
+        ? generateFieldsDescription(tool.outputSchema, tool.importantFields ?? [], tool.name)
+        : undefined;
+    tool.schema = extendSchema(tool.schema, fieldDesc);
     // Step 2: Compose
-    let handler = wrapWithErrorHandling(tool.handler, errorHandler);
+    let handler = wrapWithErrorHandling(wrapWithOrganizationContext(tool.handler), errorHandler);
     if (useFields) {
         handler = wrapWithFieldPicking(handler);
     }
     return wrapWithToolResult(wrapWithTokenLimit(handler, maxTokens));
 }
 function extendSchema(schema, desc) {
-    return schema.extend({
-        fields: z.string().describe(desc),
-    });
+    const extension = {
+        organization: z
+            .string()
+            .optional()
+            .describe('Optional organization name. Use list_organizations to inspect available organizations.'),
+    };
+    if (desc) {
+        extension.fields = z.string().describe(desc);
+    }
+    return schema.extend(extension);
 }

package/build/handlers/transformers/wrapWithOrganizationContext.js

@@ -0,0 +1,7 @@
+import { runWithOrganization } from '../../utils/backlogOrganizationContext.js';
+export function wrapWithOrganizationContext(fn) {
+    return async (input) => {
+        const { organization, ...rest } = input;
+        return runWithOrganization(organization, () => fn(rest));
+    };
+}

package/build/httpMcpServer.js

@@ -0,0 +1,120 @@
+// Copyright (c) 2025 Nulab inc.
+// Licensed under the MIT License.
+import { randomUUID } from 'node:crypto';
+import { serve } from '@hono/node-server';
+import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { Hono } from 'hono';
+import { logger } from './utils/logger.js';
+const jsonRpcError = (code, message) => {
+    return { jsonrpc: '2.0', error: { code, message }, id: null };
+};
+const bodyContainsInitialize = (body) => {
+    return (Array.isArray(body) ? body : [body]).some(isInitializeRequest);
+};
+const buildAllowedHostnames = (host, allowedHosts) => {
+    if (allowedHosts?.length)
+        return allowedHosts;
+    const localhostHosts = ['127.0.0.1', 'localhost', '::1'];
+    return localhostHosts.includes(host)
+        ? ['localhost', '127.0.0.1', '[::1]']
+        : undefined;
+};
+const parseHostname = (hostHeader) => {
+    try {
+        return new URL(`http://${hostHeader}`).hostname;
+    }
+    catch {
+        return null;
+    }
+};
+const checkHostHeader = (hostHeader, allowedHostnames) => {
+    if (!hostHeader)
+        return jsonRpcError(-32000, 'Missing Host header');
+    const hostname = parseHostname(hostHeader);
+    if (hostname === null) {
+        return jsonRpcError(-32000, `Invalid Host header: ${hostHeader}`);
+    }
+    return allowedHostnames.includes(hostname)
+        ? null
+        : jsonRpcError(-32000, `Invalid Host: ${hostname}`);
+};
+const startNewSession = async (req, body, enableJsonResponse, transports, createServer) => {
+    const transport = new WebStandardStreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+        enableJsonResponse,
+        onsessioninitialized: (sid) => {
+            transports[sid] = transport;
+        },
+    });
+    transport.onclose = () => {
+        const sid = transport.sessionId;
+        if (sid)
+            delete transports[sid];
+    };
+    await createServer().connect(transport);
+    return transport.handleRequest(req, { parsedBody: body });
+};
+export const runHttpMcpServer = async (options) => {
+    const { host, port, path: mcpPath, version, enableJsonResponse, allowedHosts, createServer, } = options;
+    if ((host === '0.0.0.0' || host === '::') && !allowedHosts?.length) {
+        logger.warn('Binding to all interfaces without --http-allowed-hosts. ' +
+            'Set allowed Host values to prevent DNS rebinding attacks.');
+    }
+    const app = new Hono();
+    const transports = {};
+    const allowedHostnames = buildAllowedHostnames(host, allowedHosts);
+    app.get('/health', (c) => c.json({ status: 'healthy', timestamp: new Date().toISOString(), version }));
+    app.all(mcpPath, async (c) => {
+        const req = c.req.raw;
+        if (allowedHostnames) {
+            const hostError = checkHostHeader(req.headers.get('host'), allowedHostnames);
+            if (hostError)
+                return c.json(hostError, 403);
+        }
+        const sessionId = req.headers.get('mcp-session-id');
+        try {
+            if (sessionId && transports[sessionId]) {
+                return transports[sessionId].handleRequest(req);
+            }
+            if (sessionId) {
+                return c.json(jsonRpcError(-32000, 'Bad Request: Unknown or expired session ID. Send a new initialize request without mcp-session-id.'), 400);
+            }
+            if (req.method !== 'POST') {
+                return c.json(jsonRpcError(-32000, 'Bad Request: No mcp-session-id header.'), 400);
+            }
+            const parsed = await req.json().then((body) => ({ body }), () => null);
+            if (!parsed) {
+                return c.json(jsonRpcError(-32700, 'Parse error: Invalid JSON'), 400);
+            }
+            const { body } = parsed;
+            if (!bodyContainsInitialize(body)) {
+                const err = jsonRpcError(-32000, 'Bad Request: No mcp-session-id header and body is not an initialize request.');
+                return c.json(Array.isArray(body) ? [err] : err, 400);
+            }
+            return startNewSession(req, body, enableJsonResponse, transports, createServer);
+        }
+        catch (error) {
+            logger.error({ err: error }, 'Error handling MCP request');
+            return c.json(jsonRpcError(-32603, 'Internal server error'), 500);
+        }
+    });
+    const httpServer = await new Promise((resolve, reject) => {
+        const srv = serve({ fetch: app.fetch, port, hostname: host }, () => resolve(srv));
+        srv.on('error', reject);
+    });
+    const shutdown = async () => {
+        for (const sid of Object.keys(transports)) {
+            try {
+                await transports[sid].close();
+            }
+            catch {
+                /* ignore */
+            }
+            delete transports[sid];
+        }
+        httpServer.closeAllConnections();
+        await new Promise((resolve) => httpServer.close(() => resolve()));
+    };
+    return { httpServer, shutdown };
+};

package/build/index.js

@@ -1,24 +1,74 @@
 #!/usr/bin/env node
 // Copyright (c) 2025 Nulab inc.
 // Licensed under the MIT License.
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import * as backlogjs from 'backlog-js';
 import dotenv from 'dotenv';
 import { default as env } from 'env-var';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { createTranslationHelper } from './createTranslationHelper.js';
-import { registerDynamicTools, registerTools } from './registerTools.js';
-import { dynamicTools } from './tools/dynamicTools/toolsets.js';
+import { createBacklogMcpServer } from './createBacklogMcpServer.js';
+import { runHttpMcpServer } from './httpMcpServer.js';
+import { createBacklogClientRegistry } from './utils/backlogClientRegistry.js';
 import { logger } from './utils/logger.js';
-import { createToolRegistrar } from './utils/toolRegistrar.js';
-import { buildToolsetGroup } from './utils/toolsetUtils.js';
-import { wrapServerWithToolRegistry } from './utils/wrapServerWithToolRegistry.js';
 import packageJson from '../package.json' with { type: 'json' };
 const { version } = packageJson;
+// Swallow SIGPIPE and stdout/stderr EPIPE so the process doesn't crash when a
+// client disconnects mid-stream. Node.js emits EPIPE as both a Unix signal and
+// as an error event on stdout/stderr streams — both must be handled.
+process.on('SIGPIPE', () => { });
+process.stdout.on('error', (err) => {
+    if (err.code !== 'EPIPE')
+        throw err;
+});
+process.stderr.on('error', (err) => {
+    if (err.code !== 'EPIPE')
+        throw err;
+});
+process.on('uncaughtException', (error) => {
+    logger.error({ err: error }, 'Uncaught exception');
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+    logger.error({ err: reason }, 'Unhandled rejection');
+    process.exit(1);
+});
 dotenv.config();
 const argv = yargs(hideBin(process.argv))
+    .option('transport', {
+    type: 'string',
+    choices: ['stdio', 'http'],
+    describe: 'MCP transport: stdio (default) or Streamable HTTP',
+    default: env.get('MCP_TRANSPORT').default('stdio').asString().toLowerCase() ===
+        'http'
+        ? 'http'
+        : 'stdio',
+})
+    .option('http-host', {
+    type: 'string',
+    describe: 'Host to bind for HTTP transport',
+    default: env.get('MCP_HTTP_HOST').default('127.0.0.1').asString(),
+})
+    .option('http-port', {
+    type: 'number',
+    describe: 'Port for HTTP transport',
+    default: env.get('MCP_HTTP_PORT').default(3333).asPortNumber(),
+})
+    .option('http-path', {
+    type: 'string',
+    describe: 'URL path for MCP endpoint (must start with /)',
+    default: env.get('MCP_HTTP_PATH').default('/mcp').asString(),
+})
+    .option('http-json-response', {
+    type: 'boolean',
+    describe: 'Prefer JSON responses over SSE streams when supported (Streamable HTTP)',
+    default: env.get('MCP_HTTP_JSON_RESPONSE').default('false').asBool(),
+})
+    .option('http-allowed-hosts', {
+    type: 'string',
+    describe: 'Comma-separated allowed Host header values when binding to all interfaces (recommended with 0.0.0.0)',
+    default: env.get('MCP_HTTP_ALLOWED_HOSTS').default('').asString(),
+})
     .option('max-tokens', {
     type: 'number',
     describe: 'Maximum number of tokens allowed in the response',
@@ -57,40 +107,80 @@ Available toolsets:
     default: env.get('ENABLE_DYNAMIC_TOOLSETS').default('false').asBool(),
 })
     .parseSync();
-const domain = env.get('BACKLOG_DOMAIN').required().asString();
-const apiKey = env.get('BACKLOG_API_KEY').required().asString();
-const backlog = new backlogjs.Backlog({ host: domain, apiKey: apiKey });
+const clientRegistry = createBacklogClientRegistry();
+const backlog = clientRegistry.createScopedClient();
 const useFields = argv.optimizeResponse;
-const server = wrapServerWithToolRegistry(new McpServer({
-    name: 'backlog',
-    title: useFields ? 'backlog (field selection enabled)' : 'backlog',
-    version,
-}));
 const transHelper = createTranslationHelper();
 const maxTokens = argv.maxTokens;
 const prefix = argv.prefix;
 let enabledToolsets = argv.enableToolsets;
 // If dynamic toolsets are enabled, remove "all" to allow for selective enabling via commands
 if (argv.dynamicToolsets) {
-    enabledToolsets = enabledToolsets.filter((a) => a != 'all');
+    enabledToolsets = enabledToolsets.filter((a) => a !== 'all');
 }
 const mcpOption = { useFields: useFields, maxTokens, prefix };
-const toolsetGroup = buildToolsetGroup(backlog, transHelper, enabledToolsets);
-// Register all tools
-registerTools(server, toolsetGroup, mcpOption);
-// Register dynamic tool management tools if enabled
-if (argv.dynamicToolsets) {
-    const registrar = createToolRegistrar(server, toolsetGroup, mcpOption);
-    const dynamicToolsetGroup = dynamicTools(registrar, transHelper, toolsetGroup);
-    registerDynamicTools(server, dynamicToolsetGroup, prefix);
-}
+// Factory: creates a fresh MCP server with all tools registered.
+// Used once for stdio; one fresh instance per HTTP session for Streamable HTTP.
+const createServer = () => createBacklogMcpServer({
+    version,
+    useFields,
+    backlog,
+    clientRegistry,
+    transHelper,
+    enabledToolsets,
+    mcpOption,
+    dynamicToolsets: argv.dynamicToolsets,
+});
 if (argv.exportTranslations) {
     const data = transHelper.dump();
     // eslint-disable-next-line no-console
     console.log(JSON.stringify(data, null, 2));
     process.exit(0);
 }
+function normalizeHttpPath(p) {
+    if (!p.startsWith('/')) {
+        return `/${p}`;
+    }
+    return p;
+}
 async function main() {
+    if (argv.transport === 'http') {
+        const httpPath = normalizeHttpPath(argv.httpPath);
+        const allowedHostsRaw = argv.httpAllowedHosts;
+        const allowedHosts = allowedHostsRaw && allowedHostsRaw.trim().length > 0
+            ? allowedHostsRaw
+                .split(',')
+                .map((h) => h.trim())
+                .filter(Boolean)
+            : undefined;
+        const { shutdown } = await runHttpMcpServer({
+            host: argv.httpHost,
+            port: argv.httpPort,
+            path: httpPath,
+            version,
+            enableJsonResponse: argv.httpJsonResponse,
+            allowedHosts,
+            createServer,
+        });
+        process.once('SIGINT', () => {
+            void shutdown()
+                .catch((err) => logger.error({ err }, 'Error during shutdown'))
+                .finally(() => process.exit(0));
+        });
+        process.once('SIGTERM', () => {
+            void shutdown()
+                .catch((err) => logger.error({ err }, 'Error during shutdown'))
+                .finally(() => process.exit(0));
+        });
+        logger.info({
+            transport: 'http',
+            host: argv.httpHost,
+            port: argv.httpPort,
+            path: httpPath,
+        }, 'Backlog MCP Server listening (Streamable HTTP)');
+        return;
+    }
+    const server = createServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     logger.info('Backlog MCP Server running on stdio');

package/build/tools/dynamicTools/organizations.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export function organizationTools(registry, { t }) {
+    return {
+        toolsets: [
+            {
+                name: 'organization_metadata',
+                description: 'Tools for inspecting configured Backlog organizations.',
+                enabled: true,
+                tools: [listOrganizationsTool(registry, t)],
+            },
+        ],
+    };
+}
+export function listOrganizationsTool(registry, t) {
+    return {
+        name: 'list_organizations',
+        description: t('TOOL_LIST_ORGANIZATIONS_DESCRIPTION', 'List configured Backlog organizations and identify the default organization.'),
+        schema: z.object({}),
+        handler: async () => {
+            const organizations = registry.listOrganizations().map(toToolOutput);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(organizations, null, 2),
+                    },
+                ],
+            };
+        },
+    };
+}
+function toToolOutput(organization) {
+    return {
+        name: organization.name,
+        domain: organization.domain,
+        isDefault: organization.isDefault,
+    };
+}

package/build/tools/dynamicTools/toolsets.js

@@ -24,7 +24,7 @@ const enableToolsetSchema = buildToolSchema((t) => ({
 export const enableToolsetTool = (toolRegistrar, { t }) => {
     return {
         name: 'enable_toolset',
-        description: t('TOOL_ENABLE_TOOLSET_DESCRIPTION', 'Enable one of the sets of tools the GitHub MCP server provides, use get_toolset_tools and list_available_toolsets first to see what this will enable'),
+        description: t('TOOL_ENABLE_TOOLSET_DESCRIPTION', 'Enable one of the Backlog MCP server toolsets. Use get_toolset_tools and list_available_toolsets first to inspect what this will enable.'),
         schema: z.object(enableToolsetSchema(t)),
         handler: async ({ toolset }) => {
             const msg = await toolRegistrar.enableToolsetAndRefresh(toolset);

package/build/utils/backlogClientRegistry.js

@@ -0,0 +1,132 @@
+import { Backlog } from 'backlog-js';
+import { getCurrentOrganization } from './backlogOrganizationContext.js';
+export function createBacklogClientRegistry(input = {}) {
+    const env = input.env ?? process.env;
+    const multiOrgRegistry = createMultiOrganizationRegistryFromEnv(env);
+    if (multiOrgRegistry) {
+        return multiOrgRegistry;
+    }
+    const domain = env.BACKLOG_DOMAIN;
+    const apiKey = env.BACKLOG_API_KEY;
+    if (!domain || !apiKey) {
+        throw new Error('Configure either BACKLOG_ORG_<NAME>_DOMAIN and BACKLOG_ORG_<NAME>_API_KEY with BACKLOG_DEFAULT_ORG, or both BACKLOG_DOMAIN and BACKLOG_API_KEY.');
+    }
+    const defaultName = 'default';
+    const client = new Backlog({ host: domain, apiKey });
+    const info = {
+        name: defaultName,
+        domain,
+        isDefault: true,
+    };
+    return {
+        resolveClient: (organization) => {
+            if (organization && organization !== defaultName) {
+                throw new Error(`Unknown organization '${organization}'. Use list_organizations to inspect available organizations.`);
+            }
+            return client;
+        },
+        createScopedClient: () => createBacklogClientProxy(() => {
+            const organization = getCurrentOrganization();
+            if (organization && organization !== defaultName) {
+                throw new Error(`Unknown organization '${organization}'. Use list_organizations to inspect available organizations.`);
+            }
+            return client;
+        }),
+        listOrganizations: () => [info],
+        getDefaultOrganization: () => defaultName,
+    };
+}
+function createMultiOrganizationRegistryFromEnv(env) {
+    const organizations = new Map();
+    let hasMultiOrgKeys = false;
+    for (const [key, value] of Object.entries(env)) {
+        const match = /^BACKLOG_ORG_(.+)_(DOMAIN|API_KEY)$/.exec(key);
+        if (!match) {
+            continue;
+        }
+        hasMultiOrgKeys = true;
+        const [, organization, field] = match;
+        const config = organizations.get(organization) ?? {};
+        if (field === 'DOMAIN') {
+            config.domain = value;
+        }
+        else {
+            config.apiKey = value;
+        }
+        organizations.set(organization, config);
+    }
+    if (!hasMultiOrgKeys) {
+        return undefined;
+    }
+    const invalidOrganizations = Array.from(organizations.entries())
+        .filter(([, config]) => !config.domain || !config.apiKey)
+        .map(([organization, config]) => {
+        const missing = [];
+        if (!config.domain)
+            missing.push(`BACKLOG_ORG_${organization}_DOMAIN`);
+        if (!config.apiKey)
+            missing.push(`BACKLOG_ORG_${organization}_API_KEY`);
+        return `${organization} (missing: ${missing.join(', ')})`;
+    })
+        .sort();
+    if (invalidOrganizations.length > 0) {
+        throw new Error(`Incomplete multi-organization configuration. ${invalidOrganizations.join('; ')}`);
+    }
+    if (organizations.size === 0) {
+        throw new Error('No valid multi-organization configuration was found. Define BACKLOG_ORG_<NAME>_DOMAIN and BACKLOG_ORG_<NAME>_API_KEY pairs.');
+    }
+    const defaultOrganization = env.BACKLOG_DEFAULT_ORG;
+    if (!defaultOrganization) {
+        throw new Error('BACKLOG_DEFAULT_ORG is required when using BACKLOG_ORG_<NAME>_DOMAIN and BACKLOG_ORG_<NAME>_API_KEY.');
+    }
+    const clients = new Map();
+    // At this point, all organizations have been validated to have both domain and apiKey
+    const validatedOrganizations = organizations;
+    const organizationInfo = Array.from(validatedOrganizations.entries()).map(([name, config]) => {
+        clients.set(name, new Backlog({
+            host: config.domain,
+            apiKey: config.apiKey,
+        }));
+        return {
+            name,
+            domain: config.domain,
+            isDefault: name === defaultOrganization,
+        };
+    });
+    if (!clients.has(defaultOrganization)) {
+        throw new Error(`BACKLOG_DEFAULT_ORG '${defaultOrganization}' does not match any configured organization. Use list_organizations to inspect available organizations.`);
+    }
+    return {
+        resolveClient: (organization) => {
+            const orgName = organization ?? defaultOrganization;
+            return resolveKnownClient(clients, orgName);
+        },
+        createScopedClient: () => createBacklogClientProxy(() => {
+            const organization = getCurrentOrganization();
+            return organization === undefined
+                ? resolveKnownClient(clients, defaultOrganization)
+                : resolveKnownClient(clients, organization);
+        }),
+        listOrganizations: () => organizationInfo,
+        getDefaultOrganization: () => defaultOrganization,
+    };
+}
+function resolveKnownClient(clients, organization) {
+    const client = clients.get(organization);
+    if (!client) {
+        throw new Error(`Unknown organization '${organization}'. Use list_organizations to inspect available organizations.`);
+    }
+    return client;
+}
+function createBacklogClientProxy(resolveClient) {
+    return new Proxy({}, {
+        get(_target, prop) {
+            const client = resolveClient();
+            const value = Reflect.get(client, prop);
+            if (typeof value === 'function') {
+                return value.bind(client);
+            }
+            return value;
+        },
+    });
+}

package/build/utils/backlogOrganizationContext.js

@@ -0,0 +1,8 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+const organizationStorage = new AsyncLocalStorage();
+export function runWithOrganization(organization, fn) {
+    return organizationStorage.run(organization, fn);
+}
+export function getCurrentOrganization() {
+    return organizationStorage.getStore();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "backlog-mcp-server",
-  "version": "0.9.1",
+  "version": "0.11.0",
   "type": "module",
   "bin": {
     "backlog-mcp-server": "./build/index.js"
@@ -27,12 +27,14 @@
     "build"
   ],
   "dependencies": {
+    "@hono/node-server": "^1.19.14",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "backlog-js": "^0.16.0",
     "cosmiconfig": "^9.0.0",
     "dotenv": "^16.5.0",
     "env-var": "^7.5.0",
     "graphql": "^16.11.0",
+    "hono": "^4.12.12",
     "pino": "^9.9.0",
     "pino-pretty": "^13.1.1",
     "yargs": "^18.0.0",