bimp-mcp 0.2.0

package/dist/client.d.ts

@@ -0,0 +1,23 @@
+export interface BimpClientConfig {
+    email: string;
+    password: string;
+    companyCode: string;
+    baseUrl?: string;
+    timeout?: number;
+}
+export declare class BimpClient {
+    private config;
+    private tokens;
+    private loginPromise;
+    constructor(config: BimpClientConfig);
+    request(method: string, path: string, params?: Record<string, unknown>, options?: {
+        timeout?: number;
+    }): Promise<unknown>;
+    switchCompany(codeOrUuid: string): Promise<void>;
+    listCompanies(): Promise<unknown>;
+    private ensureAuthenticated;
+    private login;
+    private refreshAuth;
+    private executeRequest;
+    private rawFetch;
+}

package/dist/client.js

@@ -0,0 +1,160 @@
+export class BimpClient {
+    config;
+    tokens = null;
+    loginPromise = null;
+    constructor(config) {
+        this.config = {
+            ...config,
+            baseUrl: config.baseUrl ?? "https://app.bimpsoft.com",
+            timeout: config.timeout ?? 30_000,
+        };
+    }
+    async request(method, path, params = {}, options) {
+        await this.ensureAuthenticated();
+        const result = await this.executeRequest(method, path, params, options?.timeout);
+        if (result.status === 401) {
+            await this.refreshAuth();
+            const retry = await this.executeRequest(method, path, params, options?.timeout);
+            if (!retry.ok) {
+                throw new Error(`BIMP API error: ${retry.status} on ${method} ${path}`);
+            }
+            return retry.data;
+        }
+        if (!result.ok) {
+            throw new Error(`BIMP API error: ${result.status} on ${method} ${path}`);
+        }
+        return result.data;
+    }
+    async switchCompany(codeOrUuid) {
+        if (!this.tokens) {
+            throw new Error("Must be logged in before switching company");
+        }
+        const body = codeOrUuid.includes("-")
+            ? { uuid: codeOrUuid }
+            : { code: codeOrUuid };
+        const resp = await this.rawFetch("POST", "/org2/auth/api-selectCompany", body, { "access-token": this.tokens.accessToken });
+        const json = (await resp.json());
+        if (!json.success) {
+            throw new Error("Failed to switch company");
+        }
+        this.tokens.companyAccessToken = json.data.companyAccessToken;
+    }
+    async listCompanies() {
+        await this.ensureAuthenticated();
+        const resp = await this.rawFetch("POST", "/org2/company/api-readDetailedList", {}, { "access-token": this.tokens.accessToken });
+        const json = (await resp.json());
+        return json.data;
+    }
+    async ensureAuthenticated() {
+        if (this.tokens)
+            return;
+        if (this.loginPromise) {
+            await this.loginPromise;
+            return;
+        }
+        this.loginPromise = this.login();
+        try {
+            await this.loginPromise;
+        }
+        finally {
+            this.loginPromise = null;
+        }
+    }
+    async login() {
+        const loginResp = await this.rawFetch("POST", "/org2/auth/api-login", { email: this.config.email, password: this.config.password }, {});
+        const loginJson = (await loginResp.json());
+        if (!loginJson.success) {
+            throw new Error("BIMP login failed");
+        }
+        const selectResp = await this.rawFetch("POST", "/org2/auth/api-selectCompany", { code: this.config.companyCode }, { "access-token": loginJson.data.accessToken });
+        const selectJson = (await selectResp.json());
+        if (!selectJson.success) {
+            throw new Error("BIMP company selection failed");
+        }
+        this.tokens = {
+            accessToken: loginJson.data.accessToken,
+            refreshToken: loginJson.data.refreshToken,
+            companyAccessToken: selectJson.data.companyAccessToken,
+        };
+    }
+    async refreshAuth() {
+        if (!this.tokens) {
+            await this.login();
+            return;
+        }
+        try {
+            const refreshResp = await this.rawFetch("POST", "/org2/auth/api-refresh", { refreshToken: this.tokens.refreshToken }, { "access-token": this.tokens.accessToken });
+            if (!refreshResp.ok) {
+                this.tokens = null;
+                await this.login();
+                return;
+            }
+            const refreshJson = (await refreshResp.json());
+            const selectResp = await this.rawFetch("POST", "/org2/auth/api-selectCompany", { code: this.config.companyCode }, { "access-token": refreshJson.data.accessToken });
+            const selectJson = (await selectResp.json());
+            this.tokens = {
+                accessToken: refreshJson.data.accessToken,
+                refreshToken: refreshJson.data.refreshToken,
+                companyAccessToken: selectJson.data.companyAccessToken,
+            };
+        }
+        catch {
+            this.tokens = null;
+            await this.login();
+        }
+    }
+    async executeRequest(method, pathTemplate, params, timeout) {
+        const resp = await this.rawFetch(method, pathTemplate, params, { "access-token": this.tokens.companyAccessToken }, timeout);
+        if (resp.status === 401) {
+            return { ok: false, status: 401, data: null };
+        }
+        const json = (await resp.json());
+        return { ok: resp.ok, status: resp.status, data: json };
+    }
+    async rawFetch(method, pathTemplate, params, headers, timeout) {
+        let path = pathTemplate;
+        const bodyParams = { ...params };
+        const pathParamRegex = /\{(\w+)\}/g;
+        let match;
+        while ((match = pathParamRegex.exec(pathTemplate)) !== null) {
+            const paramName = match[1];
+            if (paramName in bodyParams) {
+                path = path.replace(`{${paramName}}`, String(bodyParams[paramName]));
+                delete bodyParams[paramName];
+            }
+        }
+        let url = `${this.config.baseUrl}${path}`;
+        const fetchOptions = {
+            method,
+            headers: {
+                "accept-language": "uk-UA",
+                "content-type": "application/json",
+                ...headers,
+            },
+        };
+        if (method === "GET") {
+            const queryParams = new URLSearchParams();
+            for (const [key, value] of Object.entries(bodyParams)) {
+                if (value !== undefined && value !== null) {
+                    queryParams.set(key, String(value));
+                }
+            }
+            const qs = queryParams.toString();
+            if (qs)
+                url += `?${qs}`;
+        }
+        else {
+            fetchOptions.body = JSON.stringify(bodyParams);
+        }
+        const controller = new AbortController();
+        const timeoutMs = timeout ?? this.config.timeout;
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        fetchOptions.signal = controller.signal;
+        try {
+            return await fetch(url, fetchOptions);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { readFileSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import * as z from "zod";
+import { BimpClient } from "./client.js";
+import { generateTools } from "./tool-generator.js";
+import { createUtilityTools } from "./utilities.js";
+import { createNomenclaturesTools } from "./nomenclatures-extended.js";
+import { PROMPT_TEXTS } from "./prompts.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const config = {
+    email: process.env.BIMP_EMAIL ?? "",
+    password: process.env.BIMP_PASSWORD ?? "",
+    companyCode: process.env.BIMP_COMPANY_CODE ?? "",
+    baseUrl: process.env.BIMP_BASE_URL,
+};
+const specPath = resolve(__dirname, "..", "bimp-api.json");
+const spec = JSON.parse(readFileSync(specPath, "utf-8"));
+const client = new BimpClient(config);
+const generatedTools = generateTools(spec);
+const toolMap = new Map();
+for (const tool of generatedTools) {
+    toolMap.set(tool.name, tool);
+}
+const utilityTools = createUtilityTools(client, toolMap);
+const nomenclaturesTools = createNomenclaturesTools(client);
+const server = new McpServer({ name: "bimp-mcp", version: "0.1.0" }, { capabilities: { logging: {} } });
+// Register prompts via McpServer (uses Zod, type-safe)
+for (const [name, prompt] of Object.entries(PROMPT_TEXTS)) {
+    server.registerPrompt(name, { description: prompt.description }, () => ({
+        messages: [
+            {
+                role: "user",
+                content: { type: "text", text: prompt.text },
+            },
+        ],
+    }));
+}
+// Register auth tools via McpServer
+server.registerTool("bimp_auth_listCompanies", {
+    description: "List all companies accessible to the current user",
+    inputSchema: z.object({}),
+}, async () => {
+    const companies = await client.listCompanies();
+    return {
+        content: [
+            { type: "text", text: JSON.stringify(companies, null, 2) },
+        ],
+    };
+});
+server.registerTool("bimp_auth_switchCompany", {
+    description: "Switch to a different company by code (e.g. '000001398') or UUID",
+    inputSchema: z.object({
+        codeOrUuid: z
+            .string()
+            .describe("Company code or UUID to switch to"),
+    }),
+}, async ({ codeOrUuid }) => {
+    await client.switchCompany(codeOrUuid);
+    return {
+        content: [
+            { type: "text", text: `Switched to company: ${codeOrUuid}` },
+        ],
+    };
+});
+// Use low-level server for dynamic tool registration (raw JSON Schema from OpenAPI)
+const lowLevelServer = server.server;
+lowLevelServer.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        ...generatedTools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+        })),
+        // Auth tools are registered via McpServer, but we need them in the list too
+        {
+            name: "bimp_auth_listCompanies",
+            description: "List all companies accessible to the current user",
+            inputSchema: { type: "object", properties: {} },
+        },
+        {
+            name: "bimp_auth_switchCompany",
+            description: "Switch to a different company by code (e.g. '000001398') or UUID",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    codeOrUuid: {
+                        type: "string",
+                        description: "Company code or UUID to switch to",
+                    },
+                },
+                required: ["codeOrUuid"],
+            },
+        },
+        ...utilityTools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+        })),
+        ...nomenclaturesTools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+        })),
+    ],
+}));
+lowLevelServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const params = (args ?? {});
+    try {
+        // Auth tools
+        if (name === "bimp_auth_listCompanies") {
+            const companies = await client.listCompanies();
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(companies, null, 2) },
+                ],
+            };
+        }
+        if (name === "bimp_auth_switchCompany") {
+            await client.switchCompany(params.codeOrUuid);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Switched to company: ${params.codeOrUuid}`,
+                    },
+                ],
+            };
+        }
+        // Utility tools
+        const utilityTool = utilityTools.find((t) => t.name === name);
+        if (utilityTool) {
+            const result = await utilityTool.handler(params);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        // Nomenclatures extended tools
+        const nomenclaturesTool = nomenclaturesTools.find((t) => t.name === name);
+        if (nomenclaturesTool) {
+            const result = await nomenclaturesTool.handler(params);
+            return {
+                content: [
+                    { type: "text", text: JSON.stringify(result, null, 2) },
+                ],
+            };
+        }
+        // Generated API tools
+        const toolDef = toolMap.get(name);
+        if (!toolDef) {
+            return {
+                content: [{ type: "text", text: `Unknown tool: ${name}` }],
+                isError: true,
+            };
+        }
+        const result = await client.request(toolDef.metadata.method, toolDef.metadata.path, params);
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(result, null, 2) },
+            ],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${message}` }],
+            isError: true,
+        };
+    }
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("BIMP MCP server started");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/nomenclatures-extended.d.ts

@@ -0,0 +1,6 @@
+import type { BimpClient } from "./client.js";
+import type { UtilityTool } from "./utilities.js";
+export declare const FIELD_MAP: Record<string, string>;
+export declare function toEnglish(obj: Record<string, unknown>): Record<string, unknown>;
+export declare function toCyrillic(obj: Record<string, unknown>): Record<string, unknown>;
+export declare function createNomenclaturesTools(client: BimpClient): UtilityTool[];

package/dist/nomenclatures-extended.js

@@ -0,0 +1,118 @@
+export const FIELD_MAP = {
+    uuid: "GUID",
+    name: "Наименование",
+    fullName: "НаименованиеДляПечати",
+    code: "Код",
+    article: "Артикул",
+    comment: "Комментарий",
+    barcode: "Штрихкод",
+    minStock: "МинимальныйОстаток",
+    maxStock: "МаксимальныйОстаток",
+    speedOfDemand: "speedOfDemand",
+    insuranceReserve: "insuranceReserve",
+    deliveryTerm: "deliveryTerm",
+    weight: "Вес",
+    height: "Высота",
+    width: "Ширина",
+    length: "Длина",
+    plannedCost: "ПлановаяСебестоимость",
+    isKit: "ЭтоНабор",
+    isService: "ЭтоУслуга",
+    archived: "Архив",
+    type: "ТипНоменклатуры",
+    unitOfMeasurementUuid: "ЕдиницаИзмерения.GUID",
+    expenseAccountUuid: "СчетУчетаЗатрат.GUID",
+    inventoryAccountUuid: "СчетУчетаЗапасов.GUID",
+    docType: "ТипДокумента",
+};
+const REVERSE_MAP = Object.fromEntries(Object.entries(FIELD_MAP).map(([en, cyrillic]) => [cyrillic, en]));
+export function toEnglish(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        result[REVERSE_MAP[key] ?? key] = value;
+    }
+    return result;
+}
+export function toCyrillic(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        result[FIELD_MAP[key] ?? key] = value;
+    }
+    return result;
+}
+function createNomenclaturesReadTool(client) {
+    return {
+        name: "bimp_nomenclatures_read",
+        description: "Read full product card including planning/accounting fields " +
+            "(minStock, maxStock, speedOfDemand, insuranceReserve, deliveryTerm) " +
+            "from the extended nomenclatures endpoint.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                uuid: { type: "string", description: "Product UUID" },
+            },
+            required: ["uuid"],
+        },
+        handler: async (params) => {
+            const uuid = params.uuid;
+            const response = (await client.request("POST", "/org2/nomenclatures/read", {
+                lang: "ru",
+                uid: uuid,
+            }));
+            return toEnglish(response.data);
+        },
+    };
+}
+function createNomenclaturesUpsertTool(client) {
+    return {
+        name: "bimp_nomenclatures_upsert",
+        description: "Create or update a product with planning/accounting fields. " +
+            "For update: uuid is required. For create: uuid is optional. " +
+            "Supports: minStock, maxStock, speedOfDemand, insuranceReserve, deliveryTerm, and all standard fields.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                uuid: { type: "string", description: "Product UUID (required for update, optional for create)" },
+                name: { type: "string", description: "Product name (required for create)" },
+                article: { type: "string", description: "Product article/SKU" },
+                minStock: { type: "number", description: "Minimum stock level" },
+                maxStock: { type: "number", description: "Maximum stock level" },
+                speedOfDemand: { type: "number", description: "Demand rate" },
+                insuranceReserve: { type: "number", description: "Safety stock" },
+                deliveryTerm: { type: "number", description: "Delivery time in days" },
+                unitOfMeasurementUuid: { type: "string", description: "Unit of measurement UUID" },
+                type: { type: "number", description: "Product type: 1=goods, 2=service" },
+            },
+        },
+        handler: async (params) => {
+            const { docType: _ignored, ...fields } = params;
+            const body = toCyrillic(fields);
+            body["ТипДокумента"] = "101";
+            const response = (await client.request("POST", "/org2/nomenclatures/upsert", body));
+            return { uuid: response.data.GUID };
+        },
+    };
+}
+function createNomenclaturesReadListTool(client) {
+    return {
+        name: "bimp_nomenclatures_readList",
+        description: "List all products from the extended nomenclatures endpoint. " +
+            "Returns English-mapped items including minStock field.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+        handler: async () => {
+            const response = (await client.request("POST", "/org2/nomenclatures/readList", {}));
+            const items = (response.data ?? []).map(toEnglish);
+            return { items, count: items.length };
+        },
+    };
+}
+export function createNomenclaturesTools(client) {
+    return [
+        createNomenclaturesReadTool(client),
+        createNomenclaturesUpsertTool(client),
+        createNomenclaturesReadListTool(client),
+    ];
+}

package/dist/prompts.d.ts

@@ -0,0 +1,25 @@
+interface PromptDef {
+    name: string;
+    description: string;
+    arguments?: Array<{
+        name: string;
+        description: string;
+        required?: boolean;
+    }>;
+}
+interface PromptResult {
+    messages: Array<{
+        role: "user" | "assistant";
+        content: {
+            type: "text";
+            text: string;
+        };
+    }>;
+}
+export declare const PROMPT_TEXTS: Record<string, {
+    description: string;
+    text: string;
+}>;
+export declare function getPrompts(): PromptDef[];
+export declare function handleGetPrompt(name: string, _args?: Record<string, string>): PromptResult;
+export {};