backlog-mcp-server 0.15.0 → 0.16.0

package/build/types/zod/backlogOutputDefinition.js

@@ -84,7 +84,6 @@ export const CustomFieldTypeSchema = z.nativeEnum({
     CheckBox: 7,
     Radio: 8,
 });
-export const WebhookActivityIdSchema = z.number();
 export const UserSchema = z.object({
     id: z.number(),
     userId: z.string(),
@@ -434,21 +433,6 @@ export const WikiListItemSchema = z.object({
 export const WikiCountSchema = z.object({
     count: z.number(),
 });
-export const DocumentSchema = z.object({
-    id: z.number(),
-    projectId: z.number(),
-    name: z.string(),
-    content: z.string(),
-    createdUser: UserSchema,
-    created: z.string(),
-    updatedUser: UserSchema,
-    updated: z.string(),
-});
-export const DocumentAttachmentSchema = z.object({
-    filename: z.string(),
-    body: z.any(),
-    url: z.string(),
-});
 export const DocumentTagSchema = z.object({
     id: z.number(),
     name: z.string(),

package/build/utils/backlogClientRegistry.d.ts

@@ -0,0 +1,28 @@
+import { Backlog } from 'backlog-js';
+export type BacklogOrganizationInfo = {
+    name: string;
+    domain: string;
+    isDefault: boolean;
+};
+export type BacklogClientResolver = (organization?: string) => Backlog;
+export type BacklogClientRegistry = {
+    resolveClient: BacklogClientResolver;
+    createScopedClient: () => Backlog;
+    listOrganizations: () => BacklogOrganizationInfo[];
+    getDefaultOrganization: () => string | undefined;
+    /**
+     * Whether more than one Backlog space can be addressed. Only then is it worth
+     * spending an `organization` parameter on every tool and publishing
+     * `list_organizations` — with a single space there is nothing to choose.
+     * Keyed on the configured mode, not the organization count, so a multi-org
+     * setup that happens to declare one space still exposes the parameter.
+     */
+    isMultiOrganization: boolean;
+};
+type Environment = Record<string, string | undefined>;
+type RegistryInput = {
+    env?: Environment;
+};
+export declare function createBacklogClientRegistry(input?: RegistryInput): BacklogClientRegistry;
+export declare function createOAuthBacklogClientRegistry(domain: string): BacklogClientRegistry;
+export {};

package/build/utils/backlogClientRegistry.js

@@ -39,6 +39,7 @@ export function createBacklogClientRegistry(input = {}) {
         }),
         listOrganizations: () => [info],
         getDefaultOrganization: () => defaultName,
+        isMultiOrganization: false,
     };
 }
 function createMultiOrganizationRegistryFromEnv(env) {
@@ -115,6 +116,7 @@ function createMultiOrganizationRegistryFromEnv(env) {
         }),
         listOrganizations: () => organizationInfo,
         getDefaultOrganization: () => defaultOrganization,
+        isMultiOrganization: true,
     };
 }
 function resolveKnownClient(clients, organization) {
@@ -147,6 +149,8 @@ export function createOAuthBacklogClientRegistry(domain) {
         createScopedClient: () => createBacklogClientProxy(resolveOAuthClient),
         listOrganizations: () => [info],
         getDefaultOrganization: () => defaultName,
+        // OAuth authorises against one Backlog domain per server.
+        isMultiOrganization: false,
     };
 }
 function createBacklogClientProxy(resolveClient) {

package/build/utils/backlogOrganizationContext.d.ts

@@ -0,0 +1,2 @@
+export declare function runWithOrganization<T>(organization: string | undefined, fn: () => Promise<T>): Promise<T>;
+export declare function getCurrentOrganization(): string | undefined;

package/build/utils/generateFieldsDescription.d.ts

@@ -0,0 +1,5 @@
+import { z, ZodRawShape } from 'zod';
+/**
+ * Generate GraphQL like fields and type specs from Zod types
+ */
+export declare function generateFieldsDescription(outputSchema: z.ZodObject<ZodRawShape>, importantFields?: string[], typeName?: string): string;

package/build/utils/logger.d.ts

@@ -0,0 +1,2 @@
+import pino from 'pino';
+export declare const logger: pino.Logger<never, boolean>;

package/build/utils/logger.js

@@ -3,18 +3,31 @@ if (!process.env.NODE_ENV) {
     process.env.NODE_ENV = 'production';
 }
 const isProd = process.env.NODE_ENV === 'production';
-export const logger = pino({
-    level: isProd ? 'error' : 'debug',
-    transport: isProd
-        ? undefined
-        : {
-            target: 'pino-pretty',
-            options: {
-                destination: 2,
-                colorize: true,
-                translateTime: 'SYS:yyyy-mm-dd HH:MM:ss.l',
-                ignore: 'pid,hostname',
-                singleLine: true,
+// Plain JSON on stderr. stdout carries the JSON-RPC stream on the stdio
+// transport, so a log line landing there would corrupt the protocol.
+const plainLogger = () => pino({ level: isProd ? 'error' : 'debug' }, pino.destination({ dest: 2, sync: false }));
+// `pino-pretty` is a development-only dependency, so an installed copy of this
+// package does not have it. pino resolves a transport target eagerly and throws
+// synchronously when it cannot, so asking is cheaper than probing the module
+// graph — and a dev-mode run without pino-pretty still gets its logs.
+const prettyLogger = () => {
+    try {
+        return pino({
+            level: 'debug',
+            transport: {
+                target: 'pino-pretty',
+                options: {
+                    destination: 2,
+                    colorize: true,
+                    translateTime: 'SYS:yyyy-mm-dd HH:MM:ss.l',
+                    ignore: 'pid,hostname',
+                    singleLine: true,
+                },
             },
-        },
-}, isProd ? pino.destination({ dest: 2, sync: false }) : undefined);
+        });
+    }
+    catch {
+        return plainLogger();
+    }
+};
+export const logger = isProd ? plainLogger() : prettyLogger();

package/build/utils/resolveIdOrKey.d.ts

@@ -0,0 +1,18 @@
+import { DescriptionHelper } from '../createDescriptionHelper.js';
+export type EntityName = 'issue' | 'project' | 'repository';
+type ResolveResult = {
+    ok: true;
+    value: string | number;
+} | {
+    ok: false;
+    error: Error;
+};
+export declare const resolveIdOrKey: <E extends EntityName>(entity: E, values: {
+    id?: number;
+    key?: string;
+}, t: DescriptionHelper["t"]) => ResolveResult;
+export declare const resolveIdOrName: <E extends EntityName>(entity: E, values: {
+    id?: number;
+    name?: string;
+}, t: DescriptionHelper["t"]) => ResolveResult;
+export {};

package/build/utils/runToolSafely.d.ts

@@ -0,0 +1,6 @@
+import { ErrorLike, SafeResult } from '../types/result.js';
+/**
+ * Runs a tool handler safely, catching any errors and converting to SafeResult.
+ * The `onError` handler defines how to turn unknown errors into ErrorLike objects.
+ */
+export declare function runToolSafely<I, O>(fn: (input: I) => Promise<O>, onError?: (err: unknown) => ErrorLike): (input: I) => Promise<SafeResult<O>>;

package/build/utils/tokenCounter.d.ts

@@ -0,0 +1 @@
+export declare function countTokens(text: string): number;

package/build/utils/toolRegistrar.d.ts

@@ -0,0 +1,5 @@
+import { MCPOptions } from '../types/mcp.js';
+import { ToolRegistrar } from '../types/tool.js';
+import { ToolsetGroup } from '../types/toolsets.js';
+import { BacklogMCPServer } from './wrapServerWithToolRegistry.js';
+export declare function createToolRegistrar(server: BacklogMCPServer, toolsetGroup: ToolsetGroup, options: MCPOptions): ToolRegistrar;

package/build/utils/toolsetUtils.d.ts

@@ -0,0 +1,6 @@
+import { Backlog } from 'backlog-js';
+import { ToolsetGroup, Toolset } from '../types/toolsets.js';
+import { DescriptionHelper } from '../createDescriptionHelper.js';
+export declare function getToolset(group: ToolsetGroup, name: string): Toolset | undefined;
+export declare function enableToolset(group: ToolsetGroup, name: string): string;
+export declare const buildToolsetGroup: (backlog: Backlog, helper: DescriptionHelper, enabledToolsets: string[]) => ToolsetGroup;

package/build/utils/toolsetUtils.js

@@ -11,26 +11,6 @@ export function enableToolset(group, name) {
     ts.enabled = true;
     return `Toolset ${name} enabled`;
 }
-export function getEnabledTools(group) {
-    return group.toolsets.filter((ts) => ts.enabled).flatMap((ts) => ts.tools);
-}
-export function listAvailableToolsets(group) {
-    return group.toolsets.map((ts) => ({
-        name: ts.name,
-        description: ts.description,
-        currentlyEnabled: ts.enabled,
-        canEnable: true,
-    }));
-}
-export function listToolsetTools(group, name) {
-    const ts = getToolset(group, name);
-    return (ts?.tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        toolset: name,
-        canEnable: true,
-    })) ?? []);
-}
 export const buildToolsetGroup = (backlog, helper, enabledToolsets) => {
     const toolsetGroup = allTools(backlog, helper);
     const knownNames = toolsetGroup.toolsets.map((ts) => ts.name);

package/build/utils/wrapServerWithToolRegistry.d.ts

@@ -0,0 +1,6 @@
+import type { McpServer, StandardSchemaWithJSON, ToolCallback } from '@modelcontextprotocol/server';
+export interface BacklogMCPServer extends McpServer {
+    __registeredToolNames?: Set<string>;
+    registerOnce: (name: string, description: string, schema: StandardSchemaWithJSON, handler: ToolCallback<StandardSchemaWithJSON>) => void;
+}
+export declare function wrapServerWithToolRegistry(server: McpServer): BacklogMCPServer;

package/package.json

@@ -1,10 +1,19 @@
 {
   "name": "backlog-mcp-server",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "type": "module",
   "bin": {
     "backlog-mcp-server": "./build/index.js"
   },
+  "main": "./build/lib.js",
+  "types": "./build/lib.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/lib.d.ts",
+      "import": "./build/lib.js"
+    },
+    "./package.json": "./package.json"
+  },
   "engines": {
     "node": ">=22"
   },
@@ -31,9 +40,8 @@
     "cosmiconfig": "^9.0.1",
     "env-var": "^7.5.0",
     "graphql": "^16.14.1",
-    "hono": "^4.12.27",
+    "hono": "^4.12.34",
     "pino": "^10.3.1",
-    "pino-pretty": "^13.1.3",
     "yargs": "^18.0.0",
     "zod": "^4.4.3"
   },
@@ -48,6 +56,7 @@
     "eslint": "^10.4.1",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.6",
+    "pino-pretty": "^13.1.3",
     "prettier": "^3.8.3",
     "tsx": "^4.22.4",
     "typescript": "^6.0.3",

package/build/createTranslationHelper.js

@@ -1,28 +0,0 @@
-import { cosmiconfigSync } from 'cosmiconfig';
-import os from 'os';
-export function createTranslationHelper(options) {
-    const usedKeys = {};
-    const configName = options?.configName ?? 'backlog-mcp-server';
-    // Load config file
-    const explorer = cosmiconfigSync(configName);
-    const searchPath = options?.searchDir ?? os.homedir();
-    const configResult = explorer.search(searchPath);
-    const config = configResult?.config || {};
-    function toEnvKey(key) {
-        return `BACKLOG_MCP_${key}`;
-    }
-    function t(key, fallback) {
-        const upperKey = key.toUpperCase();
-        if (usedKeys[upperKey]) {
-            return usedKeys[upperKey];
-        }
-        // Priority：ENV → config → fallback
-        const value = process.env[toEnvKey(upperKey)] || config[upperKey] || fallback;
-        usedKeys[upperKey] = value;
-        return value;
-    }
-    function dump() {
-        return { ...usedKeys };
-    }
-    return { t, dump };
-}