mcp-multi-jira 0.1.0

package/dist/mcp/remote-session.js

@@ -0,0 +1,189 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import PQueue from "p-queue";
+import { MCP_SERVER_URL, MCP_SSE_URL, refreshTokensIfNeeded, } from "../oauth/atlassian.js";
+import { debug, warn } from "../utils/log.js";
+import { PACKAGE_VERSION } from "../version.js";
+export class RemoteSession {
+    account;
+    client;
+    connected = false;
+    tokenStore;
+    scopes;
+    staticClientInfo;
+    queue;
+    tokens = null;
+    loadPromise = null;
+    refreshPromise = null;
+    constructor(account, tokenStore, scopes, staticClientInfo) {
+        this.account = account;
+        this.tokenStore = tokenStore;
+        this.scopes = scopes;
+        this.staticClientInfo = staticClientInfo;
+        this.client = this.createClient();
+        this.queue = new PQueue({ concurrency: 4 });
+    }
+    createClient() {
+        return new Client({ name: "mcp-jira", version: PACKAGE_VERSION });
+    }
+    async loadTokens() {
+        const stored = await this.tokenStore.get(this.account.alias);
+        if (!stored) {
+            throw new Error(`No tokens found for account ${this.account.alias}. Run login first.`);
+        }
+        this.tokens = stored;
+    }
+    async ensureTokensLoaded() {
+        if (this.tokens) {
+            return;
+        }
+        if (!this.loadPromise) {
+            this.loadPromise = this.loadTokens().finally(() => {
+                this.loadPromise = null;
+            });
+        }
+        await this.loadPromise;
+    }
+    refreshTokens() {
+        if (this.refreshPromise) {
+            return this.refreshPromise;
+        }
+        this.refreshPromise = (async () => {
+            const refreshed = await refreshTokensIfNeeded({
+                alias: this.account.alias,
+                tokenStore: this.tokenStore,
+                scopes: this.scopes,
+                staticClientInfo: this.staticClientInfo,
+            });
+            this.tokens = refreshed;
+            return refreshed;
+        })().finally(() => {
+            this.refreshPromise = null;
+        });
+        return this.refreshPromise;
+    }
+    tokenNeedsRefresh() {
+        if (!this.tokens) {
+            return true;
+        }
+        const now = Date.now();
+        return this.tokens.expiresAt < now + 5 * 60 * 1000;
+    }
+    async ensureValidTokens() {
+        await this.ensureTokensLoaded();
+        if (!this.tokenNeedsRefresh()) {
+            return;
+        }
+        if (!this.tokens?.refreshToken) {
+            throw new Error(`Tokens for ${this.account.alias} have expired and no refresh token is available.`);
+        }
+        await this.refreshTokens();
+    }
+    async connectStreamableHttp() {
+        if (!this.tokens) {
+            throw new Error("Missing tokens");
+        }
+        const transport = new StreamableHTTPClientTransport(new URL(MCP_SERVER_URL), {
+            requestInit: {
+                headers: {
+                    authorization: `Bearer ${this.tokens.accessToken}`,
+                },
+            },
+        });
+        await this.client.connect(transport);
+        this.connected = true;
+    }
+    async connectSse() {
+        if (!this.tokens) {
+            throw new Error("Missing tokens");
+        }
+        const eventSourceInit = {
+            headers: {
+                authorization: `Bearer ${this.tokens.accessToken}`,
+            },
+        };
+        const transport = new SSEClientTransport(new URL(MCP_SSE_URL), {
+            requestInit: {
+                headers: {
+                    authorization: `Bearer ${this.tokens.accessToken}`,
+                },
+            },
+            eventSourceInit,
+        });
+        await this.client.connect(transport);
+        this.connected = true;
+    }
+    async connect() {
+        await this.ensureValidTokens();
+        if (this.connected) {
+            return;
+        }
+        try {
+            await this.connectStreamableHttp();
+            debug(`[${this.account.alias}] Connected via Streamable HTTP`);
+        }
+        catch (err) {
+            warn(`[${this.account.alias}] Streamable HTTP failed, falling back to SSE: ${String(err)}`);
+            await this.connectSse();
+        }
+    }
+    async refreshAndReconnect() {
+        await this.ensureValidTokens();
+        await this.client.close();
+        this.client = this.createClient();
+        this.connected = false;
+        await this.connect();
+    }
+    shouldRefreshOnError(err) {
+        if (!err || typeof err !== "object") {
+            return false;
+        }
+        const code = err.code;
+        if (code === 401 || code === 403) {
+            return true;
+        }
+        const message = String(err);
+        return (message.toLowerCase().includes("unauthorized") ||
+            message.toLowerCase().includes("forbidden"));
+    }
+    async listTools() {
+        if (!this.connected) {
+            await this.connect();
+        }
+        const tools = [];
+        let cursor;
+        do {
+            const result = await this.client.listTools({ cursor });
+            tools.push(...result.tools);
+            cursor = result.nextCursor;
+        } while (cursor);
+        return tools;
+    }
+    async callTool(name, args) {
+        if (!this.connected) {
+            await this.connect();
+        }
+        return this.queue.add(async () => {
+            try {
+                return await this.client.callTool({
+                    name,
+                    arguments: args,
+                });
+            }
+            catch (err) {
+                if (this.shouldRefreshOnError(err)) {
+                    await this.refreshAndReconnect();
+                    return this.client.callTool({
+                        name,
+                        arguments: args,
+                    });
+                }
+                throw err;
+            }
+        });
+    }
+    async close() {
+        await this.client.close();
+    }
+}

package/dist/mcp/remoteSession.js

@@ -0,0 +1,163 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import PQueue from "p-queue";
+import { MCP_SERVER_URL, MCP_SSE_URL, refreshTokensIfNeeded, } from "../oauth/atlassian.js";
+import { debug, warn } from "../utils/log.js";
+export class RemoteSession {
+    account;
+    tokenStore;
+    scopes;
+    staticClientInfo;
+    client;
+    connected = false;
+    queue;
+    tokens = null;
+    constructor(account, tokenStore, scopes, staticClientInfo) {
+        this.account = account;
+        this.tokenStore = tokenStore;
+        this.scopes = scopes;
+        this.staticClientInfo = staticClientInfo;
+        this.client = this.createClient();
+        this.queue = new PQueue({ concurrency: 4 });
+    }
+    createClient() {
+        return new Client({ name: "mcp-jira", version: "0.1.0" });
+    }
+    async loadTokens() {
+        const stored = await this.tokenStore.get(this.account.alias);
+        if (!stored) {
+            throw new Error(`No tokens found for account ${this.account.alias}. Run login first.`);
+        }
+        this.tokens = stored;
+    }
+    tokenNeedsRefresh() {
+        if (!this.tokens) {
+            return true;
+        }
+        const now = Date.now();
+        return this.tokens.expiresAt < now + 5 * 60 * 1000;
+    }
+    async ensureValidTokens() {
+        if (!this.tokens) {
+            await this.loadTokens();
+        }
+        if (this.tokenNeedsRefresh()) {
+            if (!this.tokens?.refreshToken) {
+                throw new Error(`Tokens for ${this.account.alias} have expired and no refresh token is available.`);
+            }
+            const refreshed = await refreshTokensIfNeeded({
+                alias: this.account.alias,
+                tokenStore: this.tokenStore,
+                scopes: this.scopes,
+                staticClientInfo: this.staticClientInfo,
+            });
+            this.tokens = refreshed;
+        }
+    }
+    async connectStreamableHttp() {
+        if (!this.tokens) {
+            throw new Error("Missing tokens");
+        }
+        const transport = new StreamableHTTPClientTransport(new URL(MCP_SERVER_URL), {
+            requestInit: {
+                headers: {
+                    authorization: `Bearer ${this.tokens.accessToken}`,
+                },
+            },
+        });
+        await this.client.connect(transport);
+        this.connected = true;
+    }
+    async connectSse() {
+        if (!this.tokens) {
+            throw new Error("Missing tokens");
+        }
+        const transport = new SSEClientTransport(new URL(MCP_SSE_URL), {
+            requestInit: {
+                headers: {
+                    authorization: `Bearer ${this.tokens.accessToken}`,
+                },
+            },
+            eventSourceInit: {
+                headers: {
+                    authorization: `Bearer ${this.tokens.accessToken}`,
+                },
+            },
+        });
+        await this.client.connect(transport);
+        this.connected = true;
+    }
+    async connect() {
+        await this.ensureValidTokens();
+        if (this.connected) {
+            return;
+        }
+        try {
+            await this.connectStreamableHttp();
+            debug(`[${this.account.alias}] Connected via Streamable HTTP`);
+        }
+        catch (err) {
+            warn(`[${this.account.alias}] Streamable HTTP failed, falling back to SSE: ${String(err)}`);
+            await this.connectSse();
+        }
+    }
+    async refreshAndReconnect() {
+        await this.ensureValidTokens();
+        await this.client.close();
+        this.client = this.createClient();
+        this.connected = false;
+        await this.connect();
+    }
+    shouldRefreshOnError(err) {
+        if (!err || typeof err !== "object") {
+            return false;
+        }
+        const code = err.code;
+        if (code === 401 || code === 403) {
+            return true;
+        }
+        const message = String(err);
+        return (message.toLowerCase().includes("unauthorized") ||
+            message.toLowerCase().includes("forbidden"));
+    }
+    async listTools() {
+        if (!this.connected) {
+            await this.connect();
+        }
+        const tools = [];
+        let cursor;
+        do {
+            const result = await this.client.listTools({ cursor });
+            tools.push(...result.tools);
+            cursor = result.nextCursor;
+        } while (cursor);
+        return tools;
+    }
+    async callTool(name, args) {
+        if (!this.connected) {
+            await this.connect();
+        }
+        return this.queue.add(async () => {
+            try {
+                return await this.client.callTool({
+                    name,
+                    arguments: args,
+                });
+            }
+            catch (err) {
+                if (this.shouldRefreshOnError(err)) {
+                    await this.refreshAndReconnect();
+                    return this.client.callTool({
+                        name,
+                        arguments: args,
+                    });
+                }
+                throw err;
+            }
+        });
+    }
+    async close() {
+        await this.client.close();
+    }
+}

package/dist/mcp/server.js

@@ -0,0 +1,266 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { info, warn } from "../utils/log.js";
+function toolError(message) {
+    return {
+        content: [{ type: "text", text: message }],
+        isError: true,
+    };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object";
+}
+function isToolResult(value) {
+    return isRecord(value) && Array.isArray(value.content);
+}
+function sanitizeInputSchema(inputSchema) {
+    if (!inputSchema || typeof inputSchema !== "object") {
+        return inputSchema;
+    }
+    const baseSchema = { ...inputSchema };
+    if (baseSchema.properties && typeof baseSchema.properties === "object") {
+        const { cloudId: _cloudId, ...rest } = baseSchema.properties;
+        baseSchema.properties = rest;
+    }
+    if (Array.isArray(baseSchema.required)) {
+        baseSchema.required = baseSchema.required.filter((item) => item !== "cloudId");
+    }
+    return baseSchema;
+}
+function getObjectShape(schema) {
+    if (!schema || typeof schema !== "object") {
+        return null;
+    }
+    const maybeShape = schema.shape;
+    if (maybeShape && typeof maybeShape === "object") {
+        return maybeShape;
+    }
+    const maybeDefShape = schema._def?.shape;
+    if (maybeDefShape && typeof maybeDefShape === "object") {
+        return maybeDefShape;
+    }
+    if (typeof maybeDefShape === "function") {
+        try {
+            const evaluated = maybeDefShape();
+            if (evaluated && typeof evaluated === "object") {
+                return evaluated;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function buildToolSchema(inputSchema) {
+    const accountField = z
+        .string()
+        .describe("Account alias to route this call to.");
+    const accountOnly = z.object({ account: accountField }).loose();
+    const fromJSONSchema = z.fromJSONSchema;
+    if (!fromJSONSchema) {
+        return accountOnly;
+    }
+    try {
+        const remoteSchema = fromJSONSchema(sanitizeInputSchema(inputSchema) ?? { type: "object", properties: {} });
+        const shape = getObjectShape(remoteSchema);
+        if (!shape) {
+            return accountOnly;
+        }
+        const mergedShape = {
+            ...shape,
+            account: accountField,
+        };
+        return z.object(mergedShape).loose();
+    }
+    catch {
+        return accountOnly;
+    }
+}
+function normalizeToolResult(result) {
+    if (isToolResult(result)) {
+        return result;
+    }
+    if (isRecord(result) && "toolResult" in result) {
+        const structuredContent = isRecord(result.toolResult)
+            ? result.toolResult
+            : undefined;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result.toolResult),
+                },
+            ],
+            ...(structuredContent ? { structuredContent } : {}),
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result),
+            },
+        ],
+    };
+}
+async function buildAccountStatusMap(sessionManager, accounts) {
+    const statusMap = new Map();
+    const getAccountAuthStatus = sessionManager.getAccountAuthStatus;
+    if (!getAccountAuthStatus) {
+        return statusMap;
+    }
+    await Promise.all(accounts.map(async (account) => {
+        try {
+            const status = await getAccountAuthStatus(account.alias, {
+                allowPrompt: false,
+            });
+            statusMap.set(account.alias, status);
+        }
+        catch (err) {
+            statusMap.set(account.alias, {
+                status: "unknown",
+                reason: String(err),
+            });
+        }
+    }));
+    return statusMap;
+}
+function buildAccountSummaryLine(account, status) {
+    const authLabel = status ? `auth: ${status.status}` : "auth: unknown";
+    return `${account.alias}: ${account.site} (cloudId: ${account.cloudId}, ${authLabel})`;
+}
+async function collectToolsForAccount(sessionManager, account) {
+    const session = sessionManager.getSession(account.alias);
+    if (!session) {
+        return null;
+    }
+    if (sessionManager.getAccountAuthStatus) {
+        const status = await sessionManager.getAccountAuthStatus(account.alias, {
+            allowPrompt: false,
+        });
+        if (status.status !== "ok") {
+            warn(`[${account.alias}] Skipping tool discovery (auth ${status.status}).`);
+            return null;
+        }
+    }
+    return session.listTools();
+}
+async function loadRemoteTools(sessionManager, accounts) {
+    const toolMap = new Map();
+    const toolErrors = [];
+    for (const account of accounts) {
+        try {
+            const tools = await collectToolsForAccount(sessionManager, account);
+            if (!tools) {
+                continue;
+            }
+            for (const tool of tools) {
+                if (!toolMap.has(tool.name)) {
+                    toolMap.set(tool.name, {
+                        description: tool.description,
+                        inputSchema: tool.inputSchema,
+                    });
+                }
+            }
+        }
+        catch (err) {
+            const message = `[${account.alias}] Failed to fetch tools during startup: ${String(err)}`;
+            toolErrors.push(message);
+            warn(message);
+        }
+    }
+    return { toolMap, toolErrors };
+}
+function buildToolDescription(tool) {
+    const required = tool.inputSchema?.required ?? [];
+    const requiredHintList = required.filter((item) => item !== "cloudId");
+    const requiredHint = requiredHintList.length > 0
+        ? `Required parameters: ${requiredHintList.join(", ")}.`
+        : "";
+    return ((tool.description ? `${tool.description}\n\n` : "") +
+        "Required parameter: account (account alias).\n" +
+        requiredHint);
+}
+function splitAccountArgs(args) {
+    const { account, ...rest } = args;
+    return { account, rest };
+}
+function applyCloudIdFallback(sessionManager, account, tool, args) {
+    const requiredParams = tool.inputSchema?.required ?? [];
+    if (!requiredParams.includes("cloudId") || args.cloudId !== undefined) {
+        return;
+    }
+    const accountInfo = sessionManager
+        .listAccounts()
+        .find((item) => item.alias === account);
+    if (accountInfo?.cloudId && accountInfo.cloudId !== "unknown") {
+        args.cloudId = accountInfo.cloudId;
+    }
+}
+function createToolHandler(sessionManager, toolName, tool) {
+    return async (args) => {
+        const { account, rest } = splitAccountArgs(args);
+        if (!account) {
+            return toolError("Missing required parameter: account");
+        }
+        const session = sessionManager.getSession(account);
+        if (!session) {
+            return toolError(`Unknown account alias: ${account}`);
+        }
+        applyCloudIdFallback(sessionManager, account, tool, rest);
+        try {
+            const result = await session.callTool(toolName, rest);
+            return normalizeToolResult(result);
+        }
+        catch (err) {
+            return toolError(`Failed to call ${toolName} for ${account}: ${String(err)}`);
+        }
+    };
+}
+export async function startLocalServer(sessionManager, version) {
+    const server = new McpServer({ name: "mcp-jira", version }, {
+        instructions: "All Jira tools require an 'account' parameter indicating the account alias. " +
+            "Use listJiraAccounts to discover available aliases and cloud IDs. " +
+            "If a tool requires 'cloudId' and it is missing, the server will fill it from the selected account when possible. " +
+            "For JQL search use the 'jql' parameter.",
+    });
+    server.registerTool("listJiraAccounts", {
+        description: "List configured Jira account aliases and site metadata.",
+    }, async () => {
+        const accounts = sessionManager.listAccounts();
+        const statusMap = await buildAccountStatusMap(sessionManager, accounts);
+        const summary = accounts
+            .map((account) => buildAccountSummaryLine(account, statusMap.get(account.alias)))
+            .join("\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: summary || "No accounts are configured.",
+                },
+            ],
+            structuredContent: {
+                accounts: accounts.map((account) => ({
+                    ...account,
+                    auth: statusMap.get(account.alias) ?? { status: "unknown" },
+                })),
+            },
+        };
+    });
+    const sessions = sessionManager.listAccounts();
+    const { toolMap, toolErrors } = await loadRemoteTools(sessionManager, sessions);
+    if (toolMap.size === 0 && sessions.length > 0) {
+        warn(`No remote tools could be loaded. ${toolErrors.join(" ")}`.trim());
+    }
+    for (const [toolName, tool] of toolMap) {
+        server.registerTool(toolName, {
+            description: buildToolDescription(tool),
+            inputSchema: buildToolSchema(tool.inputSchema),
+        }, createToolHandler(sessionManager, toolName, tool));
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    info("MCP server is running (stdio).");
+}

package/dist/mcp/session-manager.js

@@ -0,0 +1,62 @@
+import { loadConfig } from "../config/store.js";
+import { getAuthStatusForAlias, } from "../security/token-store.js";
+import { warn } from "../utils/log.js";
+import { RemoteSession } from "./remote-session.js";
+export class SessionManager {
+    tokenStore;
+    scopes;
+    staticClientInfo;
+    tokenStoreKind;
+    sessions = new Map();
+    accounts = new Map();
+    constructor(tokenStore, scopes, staticClientInfo, tokenStoreKind) {
+        this.tokenStore = tokenStore;
+        this.scopes = scopes;
+        this.staticClientInfo = staticClientInfo;
+        this.tokenStoreKind = tokenStoreKind;
+    }
+    async loadAll() {
+        const config = await loadConfig();
+        this.accounts = new Map(Object.values(config.accounts).map((account) => [account.alias, account]));
+        for (const account of this.accounts.values()) {
+            const session = new RemoteSession(account, this.tokenStore, this.scopes, this.staticClientInfo);
+            this.sessions.set(account.alias, session);
+        }
+    }
+    listAccounts() {
+        return Array.from(this.accounts.values());
+    }
+    getSession(alias) {
+        return this.sessions.get(alias) ?? null;
+    }
+    getAccountAuthStatus(alias, options) {
+        return getAuthStatusForAlias({
+            alias,
+            tokenStore: this.tokenStore,
+            storeKind: this.tokenStoreKind,
+            allowPrompt: options?.allowPrompt ?? false,
+        });
+    }
+    async connectAll() {
+        const sessions = Array.from(this.sessions.values());
+        const results = await Promise.allSettled(sessions.map(async (session) => {
+            const status = await this.getAccountAuthStatus(session.account.alias, {
+                allowPrompt: false,
+            });
+            if (status.status !== "ok") {
+                warn(`[${session.account.alias}] Auth status ${status.status}. ${status.reason ?? "Run login."}`);
+                return;
+            }
+            await session.connect();
+        }));
+        results.forEach((result, index) => {
+            if (result.status === "rejected") {
+                const session = sessions[index];
+                warn(`[${session.account.alias}] Failed to connect: ${String(result.reason)}`);
+            }
+        });
+    }
+    async closeAll() {
+        await Promise.all(Array.from(this.sessions.values()).map((session) => session.close()));
+    }
+}