@nightsquawktech/invoiceninja-mcp-server 0.0.1

package/dist/clients/invoiceninja-client.js

@@ -0,0 +1,205 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { formatError } from "@nightsquawktech/mcp-core/catalog";
+const DEFAULT_TIMEOUT_MS = 30_000;
+/**
+ * Thin Invoice Ninja v5 REST client. One generic `call()` drives every endpoint
+ * in the catalog (the catalog spec supplies method + path + which params exist),
+ * so the MCP layer never hard-codes routes.
+ *
+ * v5 specifics vs. the AppFolio client this is modeled on:
+ *   - Auth is the `X-Api-Token` header, not HTTP Basic.
+ *   - Full CRUD (GET/POST/PUT/DELETE), not just report POSTs.
+ *   - Record IDs are hashed strings; list pagination lives in `meta.pagination`.
+ */
+export class InvoiceNinjaClient {
+    baseUrl = null;
+    apiToken = null;
+    timeoutMs = DEFAULT_TIMEOUT_MS;
+    initialized = false;
+    /** Lazily read env on first call so import-time issues don't crash startup. */
+    ensureInitialized() {
+        if (this.initialized)
+            return;
+        const baseUrl = process.env.INVOICENINJA_BASE_URL;
+        const apiToken = process.env.INVOICENINJA_API_TOKEN;
+        const timeoutRaw = process.env.INVOICENINJA_TIMEOUT_MS;
+        const missing = [];
+        if (!baseUrl)
+            missing.push("INVOICENINJA_BASE_URL");
+        if (!apiToken)
+            missing.push("INVOICENINJA_API_TOKEN");
+        if (missing.length > 0) {
+            throw new Error(`Missing required environment variables: ${missing.join(", ")}`);
+        }
+        this.baseUrl = baseUrl.replace(/\/+$/, "");
+        this.apiToken = apiToken;
+        if (timeoutRaw) {
+            const t = Number.parseInt(timeoutRaw, 10);
+            if (Number.isFinite(t) && t >= 1_000)
+                this.timeoutMs = t;
+        }
+        this.initialized = true;
+    }
+    /** Substitute {placeholders} in the path template from pathParams. */
+    buildPath(spec, pathParams) {
+        return spec.path.replace(/\{([^}]+)\}/g, (_m, key) => {
+            const v = pathParams[key];
+            if (v === undefined || v === null || v === "") {
+                throw new Error(`Missing path parameter "${key}" for ${spec.slug}`);
+            }
+            return encodeURIComponent(String(v));
+        });
+    }
+    buildQuery(query) {
+        const usp = new URLSearchParams();
+        for (const [k, v] of Object.entries(query)) {
+            if (v === undefined || v === null || v === "")
+                continue;
+            if (Array.isArray(v)) {
+                for (const item of v)
+                    usp.append(`${k}[]`, String(item));
+            }
+            else {
+                usp.append(k, String(v));
+            }
+        }
+        const s = usp.toString();
+        return s ? `?${s}` : "";
+    }
+    /** Write a pre-mutation backup of the request (+ optional prior record). */
+    writeBackup(spec, opts, prior) {
+        const dir = mkdtempSync(join(tmpdir(), "invoiceninja-mcp-"));
+        const file = join(dir, `${spec.slug}.json`);
+        writeFileSync(file, JSON.stringify({
+            slug: spec.slug,
+            method: spec.method,
+            path: spec.path,
+            pathParams: opts.pathParams ?? {},
+            query: opts.query ?? {},
+            body: opts.body ?? {},
+            authorizationNote: opts.authorizationNote ?? null,
+            priorRecord: prior ?? null,
+        }, null, 2));
+        return file;
+    }
+    async fetchJson(url, init) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const res = await fetch(url, { ...init, signal: controller.signal });
+            const text = await res.text();
+            let data = null;
+            if (text) {
+                try {
+                    data = JSON.parse(text);
+                }
+                catch {
+                    data = text;
+                }
+            }
+            return { ok: res.ok, status: res.status, data, text };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * Standard headers. For multipart uploads, omit Content-Type so fetch sets the
+     * multipart/form-data boundary (with its random delimiter) itself.
+     */
+    headers(multipart = false) {
+        const h = {
+            "X-Api-Token": this.apiToken,
+            "X-Requested-With": "XMLHttpRequest",
+            Accept: "application/json",
+        };
+        if (!multipart)
+            h["Content-Type"] = "application/json";
+        return h;
+    }
+    /**
+     * Execute one catalog endpoint. The caller has already validated params against
+     * the spec; this performs path substitution, the HTTP call, and (for mutating
+     * endpoints) a pre-call backup.
+     */
+    async call(spec, opts = {}) {
+        try {
+            this.ensureInitialized();
+            const path = this.buildPath(spec, opts.pathParams ?? {});
+            const query = this.buildQuery(opts.query ?? {});
+            const url = `${this.baseUrl}${path}${query}`;
+            let backupPath;
+            if (spec.mutating) {
+                // Best-effort: capture the current record before PUT/DELETE so the change is reversible.
+                // Derive the show URL from the endpoint's own path (replace {id}) — NOT from category,
+                // which can differ from the real resource segment on singular/plural mismatches.
+                let prior = null;
+                if ((spec.method === "PUT" || spec.method === "DELETE") && /\{id\}/.test(spec.path) && opts.pathParams?.id) {
+                    try {
+                        const showPath = spec.path.replace("{id}", encodeURIComponent(String(opts.pathParams.id)));
+                        const priorRes = await this.fetchJson(`${this.baseUrl}${showPath}`, {
+                            method: "GET",
+                            headers: this.headers(),
+                        });
+                        if (priorRes.ok)
+                            prior = priorRes.data;
+                    }
+                    catch {
+                        /* prior-record capture is best-effort */
+                    }
+                }
+                backupPath = this.writeBackup(spec, opts, prior);
+            }
+            const isMultipart = spec.requestBody?.contentType === "multipart/form-data";
+            const init = { method: spec.method, headers: this.headers(isMultipart) };
+            if (isMultipart) {
+                // Invoice Ninja registers the upload routes as PUT but expects clients to POST with a
+                // `_method=PUT` form field (Laravel method spoofing) — a JSON body 404s with
+                // "Method not supported for this route". Build multipart/form-data instead.
+                const form = new FormData();
+                const body = (opts.body ?? {});
+                const wantsSpoof = (spec.requestBody?.fields ?? []).some((f) => f.name === "_method");
+                if (body._method !== undefined && body._method !== null) {
+                    form.append("_method", String(body._method));
+                }
+                else if (wantsSpoof) {
+                    form.append("_method", "PUT");
+                }
+                // Pass through any extra scalar body fields (e.g. an import's `import_type`).
+                for (const [k, v] of Object.entries(body)) {
+                    if (k === "_method" || v === undefined || v === null || typeof v === "object")
+                        continue;
+                    form.append(k, String(v));
+                }
+                const fileField = opts.fileField ?? "documents[]";
+                for (const p of opts.files ?? []) {
+                    const buf = await readFile(p);
+                    // The filename (3rd arg) is mandatory — without it the part has no filename and
+                    // Laravel won't register it as an uploaded file even though routing succeeds.
+                    form.append(fileField, new Blob([buf]), basename(p));
+                }
+                init.body = form;
+            }
+            else if (spec.method !== "GET" && spec.method !== "DELETE" && opts.body) {
+                init.body = JSON.stringify(opts.body);
+            }
+            const res = await this.fetchJson(url, init);
+            if (!res.ok) {
+                return {
+                    result: null,
+                    isError: true,
+                    error: `HTTP ${res.status}: ${typeof res.data === "string" ? res.data : JSON.stringify(res.data)}`,
+                    backupPath,
+                };
+            }
+            return { result: res.data, isError: false, error: null, backupPath };
+        }
+        catch (error) {
+            return { result: null, isError: true, error: formatError(error) };
+        }
+    }
+}
+export const invoiceNinjaClient = new InvoiceNinjaClient();

package/dist/helpers/register-endpoint-tools.js

@@ -0,0 +1,27 @@
+import { RegisterTool } from "@nightsquawktech/mcp-core/catalog";
+import { listEndpointsTool } from "../tools/list-endpoints.js";
+import { describeEndpointTool } from "../tools/describe-endpoint.js";
+import { callEndpointTool } from "../tools/call-endpoint.js";
+import { loadIndex } from "../catalog/endpoint-spec.js";
+/**
+ * Registers the consolidated Invoice Ninja tools with the MCP server.
+ *
+ * Instead of one tool per endpoint (~379 tools = heavy context cost and poor tool
+ * selection), we expose three tools backed by the endpoint catalog:
+ *   - list_endpoints      discover endpoints by category / search / read-vs-mutating
+ *   - describe_endpoint   full parameter spec for one endpoint
+ *   - call_endpoint       validate against the catalog spec, then execute (guarded writes)
+ *
+ * Boot-time sanity check: the catalog index must load and be non-empty, so a
+ * missing/uncopied catalog fails fast at startup rather than on first tool call.
+ */
+export function registerAllEndpointTools(server) {
+    const index = loadIndex();
+    if (!index.endpoints || index.endpoints.length === 0) {
+        throw new Error("Endpoint catalog is empty or missing — expected src/catalog/index.json with endpoints. " +
+            "Did the build copy the catalog into dist/?");
+    }
+    RegisterTool(server, listEndpointsTool);
+    RegisterTool(server, describeEndpointTool);
+    RegisterTool(server, callEndpointTool);
+}

package/dist/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { InvoiceNinjaMCPServer } from "./server/invoiceninja-mcp-server.js";
+import { registerAllEndpointTools } from "./helpers/register-endpoint-tools.js";
+const server = InvoiceNinjaMCPServer.GetServer();
+registerAllEndpointTools(server);
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/server/invoiceninja-mcp-server.js

@@ -0,0 +1,18 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export class InvoiceNinjaMCPServer {
+    static instance = null;
+    constructor() { }
+    static GetServer() {
+        if (InvoiceNinjaMCPServer.instance === null) {
+            InvoiceNinjaMCPServer.instance = new McpServer({
+                name: "Invoice Ninja MCP Server",
+                version: "0.0.1",
+            }, {
+                capabilities: {
+                    tools: {},
+                },
+            });
+        }
+        return InvoiceNinjaMCPServer.instance;
+    }
+}

package/dist/tools/call-endpoint.js

@@ -0,0 +1,153 @@
+import { existsSync } from "node:fs";
+import { z } from "zod";
+import { loadEndpointSpec, loadIndex, suggestSlugs } from "../catalog/endpoint-spec.js";
+import { invoiceNinjaClient } from "../clients/invoiceninja-client.js";
+const schema = z.object({
+    endpoint_name: z
+        .string()
+        .describe("The endpoint slug to call, e.g. 'get_invoices' or 'show_invoice'. See list_endpoints / describe_endpoint."),
+    path_params: z
+        .record(z.union([z.string(), z.number()]))
+        .optional()
+        .describe("Values for {placeholders} in the path, e.g. { id: 'D2J234DFA' }. Required ones must be present."),
+    query: z
+        .record(z.any())
+        .optional()
+        .describe("Query-string parameters keyed by name from describe_endpoint, e.g. { include: 'client', per_page: 50, " +
+        "status: 'active' }. Arrays are serialized as key[]=value."),
+    body: z
+        .record(z.any())
+        .optional()
+        .describe("Request-body object for POST/PUT (keys from describe_endpoint's requestBody.fields)."),
+    files: z
+        .array(z.string())
+        .optional()
+        .describe("Local file path(s) to upload for multipart endpoints (the upload_* endpoints, e.g. " +
+        "upload_expense / upload_invoice_document to attach a receipt). Each is sent as documents[]."),
+    file_field: z
+        .string()
+        .optional()
+        .describe("Override the multipart file field name (default 'documents[]')."),
+    authorization_confirmed: z
+        .boolean()
+        .optional()
+        .describe("REQUIRED true for mutating endpoints (POST/PUT/DELETE). Confirms the user explicitly approved this change."),
+    authorization_note: z
+        .string()
+        .optional()
+        .describe("REQUIRED for mutating endpoints: a short note describing the user's explicit approval. Stored in the backup."),
+});
+function errorText(text) {
+    return { content: [{ type: "text", text }] };
+}
+/**
+ * Executes one Invoice Ninja endpoint after validating against the catalog spec:
+ * the endpoint must exist, required path parameters must be present, and any
+ * mutating endpoint must carry authorization_confirmed=true + authorization_note
+ * (a JSON backup is written before the call). Read-only GET endpoints run freely.
+ */
+export const callEndpointTool = {
+    name: "call_endpoint",
+    description: "Call an Invoice Ninja API endpoint and return its response. Validates the endpoint name and " +
+        "required path parameters against the catalog before calling. Mutating endpoints (POST/PUT/DELETE) " +
+        "require authorization_confirmed=true and an authorization_note and are backed up before execution. " +
+        "Use describe_endpoint first to learn the exact parameters.",
+    schema,
+    handler: async ({ params }) => {
+        const name = params?.endpoint_name;
+        const spec = loadEndpointSpec(name);
+        if (!spec) {
+            const suggestions = suggestSlugs(name);
+            const total = loadIndex().endpointCount;
+            return errorText(`Unknown endpoint "${name}". ` +
+                (suggestions.length ? `Did you mean: ${suggestions.join(", ")}? ` : "") +
+                `Call list_endpoints to see all ${total} endpoints.`);
+        }
+        // Required path parameters must be present.
+        const pathParams = params?.path_params ?? {};
+        const missingPath = spec.pathParameters
+            .filter((p) => p.required)
+            .map((p) => p.name)
+            .filter((n) => {
+            const v = pathParams[n];
+            return v === undefined || v === null || (typeof v === "string" && v.trim() === "");
+        });
+        // Also catch placeholders in the path that have no provided value.
+        const placeholders = [...spec.path.matchAll(/\{([^}]+)\}/g)].map((m) => m[1]);
+        for (const ph of placeholders) {
+            if (!(ph in pathParams) && !missingPath.includes(ph))
+                missingPath.push(ph);
+        }
+        if (missingPath.length > 0) {
+            return errorText(`Missing required path parameter(s) for "${spec.slug}": ${[...new Set(missingPath)].join(", ")}. ` +
+                `Call describe_endpoint("${spec.slug}") for details.`);
+        }
+        // Enforce required query parameters (rare, but honored).
+        const query = params?.query ?? {};
+        const missingQuery = spec.queryParameters
+            .filter((p) => p.required)
+            .map((p) => p.name)
+            .filter((n) => query[n] === undefined || query[n] === null || query[n] === "");
+        if (missingQuery.length > 0) {
+            return errorText(`Missing required query parameter(s) for "${spec.slug}": ${missingQuery.join(", ")}. ` +
+                `Call describe_endpoint("${spec.slug}") for details.`);
+        }
+        // Write guard for state-changing endpoints. Defense-in-depth: any {action} route
+        // (email/mark_paid/archive/delete/clone/…) is treated as mutating even if the flag
+        // were ever miscomputed, so destructive action GETs can never slip past unguarded.
+        const isMutating = spec.mutating || /\{action\}/.test(spec.path);
+        if (isMutating) {
+            const confirmed = params?.authorization_confirmed === true;
+            const note = (params?.authorization_note ?? "").toString().trim();
+            if (!confirmed || !note) {
+                return errorText(`"${spec.slug}" is a ${spec.method} (mutating) endpoint and changes data. ` +
+                    `To proceed, re-call with authorization_confirmed=true and a non-empty authorization_note ` +
+                    `describing the user's explicit approval. A JSON backup is written before the call.`);
+            }
+        }
+        // Multipart upload endpoints (upload_*) need local file(s); a JSON body never reaches them.
+        const isMultipart = spec.requestBody?.contentType === "multipart/form-data";
+        const files = Array.isArray(params?.files) ? params.files : [];
+        if (files.length > 0 && !isMultipart) {
+            return errorText(`"${spec.slug}" does not accept file uploads (its body is ${spec.requestBody?.contentType ?? "JSON"}). ` +
+                `Remove "files" or choose a multipart upload endpoint.`);
+        }
+        if (isMultipart && files.length === 0) {
+            return errorText(`"${spec.slug}" is a multipart upload endpoint — pass file path(s) via "files", ` +
+                `e.g. files: ["C:/path/to/receipt.pdf"].`);
+        }
+        const missingFiles = files.filter((f) => !existsSync(f));
+        if (missingFiles.length > 0) {
+            return errorText(`File(s) not found: ${missingFiles.join(", ")}. Provide absolute local path(s).`);
+        }
+        const response = await invoiceNinjaClient.call(spec, {
+            pathParams,
+            query,
+            body: params?.body,
+            files: files.length ? files : undefined,
+            fileField: params?.file_field,
+            authorizationNote: params?.authorization_note,
+        });
+        if (response.isError) {
+            return errorText(`Error calling ${spec.slug} (${spec.method} ${spec.path}): ${response.error}` +
+                (response.backupPath ? ` [backup: ${response.backupPath}]` : ""));
+        }
+        const data = response.result;
+        const rowCount = Array.isArray(data?.data) ? data.data.length : undefined;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        endpoint_name: spec.slug,
+                        method: spec.method,
+                        path: spec.path,
+                        ...(rowCount !== undefined ? { rowCount } : {}),
+                        ...(response.backupPath ? { backupPath: response.backupPath } : {}),
+                        response: response.result,
+                    }),
+                },
+            ],
+        };
+    },
+};

package/dist/tools/describe-endpoint.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { loadEndpointSpec, loadIndex, suggestSlugs } from "../catalog/endpoint-spec.js";
+const schema = z.object({
+    endpoint_name: z
+        .string()
+        .describe("The endpoint slug, e.g. 'get_invoices', 'show_invoice', 'store_invoice'. See list_endpoints."),
+});
+/**
+ * Returns the full spec for one endpoint: method, path, every path/query parameter
+ * and request-body field with types, required flags, enums and descriptions, plus
+ * the mutating flag. The model calls this just before call_endpoint so it sends the
+ * exact parameter keys this endpoint expects.
+ */
+export const describeEndpointTool = {
+    name: "describe_endpoint",
+    description: "Get the full specification for a single Invoice Ninja endpoint: HTTP method, path, " +
+        "path/query parameters, request-body fields (types, required, enums, descriptions), and whether " +
+        "it mutates data. Call this before call_endpoint to know exactly what to pass.",
+    schema,
+    handler: async ({ params }) => {
+        const name = params?.endpoint_name;
+        const spec = loadEndpointSpec(name);
+        if (!spec) {
+            const suggestions = suggestSlugs(name);
+            const total = loadIndex().endpointCount;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Unknown endpoint "${name}". ` +
+                            (suggestions.length ? `Did you mean: ${suggestions.join(", ")}? ` : "") +
+                            `Call list_endpoints to see all ${total} endpoints.`,
+                    },
+                ],
+            };
+        }
+        const payload = {
+            endpoint_name: spec.slug,
+            name: spec.name,
+            method: spec.method,
+            path: spec.path,
+            category: spec.category,
+            mutating: spec.mutating,
+            description: spec.description,
+            whenToUse: spec.whenToUse,
+            pathParameters: spec.pathParameters,
+            queryParameters: spec.queryParameters,
+            headerParameters: spec.headerParameters,
+            requestBody: spec.requestBody,
+            responseSchema: spec.responseSchema,
+            ...(spec.mutating
+                ? {
+                    mutationNotice: "This endpoint changes data. call_endpoint requires authorization_confirmed=true and an " +
+                        "authorization_note, and writes a JSON backup before executing.",
+                }
+                : {}),
+        };
+        return { content: [{ type: "text", text: JSON.stringify(payload) }] };
+    },
+};

package/dist/tools/list-endpoints.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { loadIndex } from "../catalog/endpoint-spec.js";
+const schema = z.object({
+    category: z
+        .string()
+        .optional()
+        .describe("Optional category filter (the API resource tag, e.g. 'invoices', 'clients', 'payments', " +
+        "'reports'). Omit to list every endpoint. Call without args first to see all categories."),
+    mutating: z
+        .boolean()
+        .optional()
+        .describe("Optional: true = only state-changing endpoints (POST/PUT/DELETE); false = only read-only (GET)."),
+    search: z
+        .string()
+        .optional()
+        .describe("Optional case-insensitive substring matched against slug, name, path, and summary."),
+});
+/**
+ * Lightweight discovery tool. Returns slug, method, path, category, mutating flag
+ * and a one-line summary per endpoint so the model can pick one, then call
+ * describe_endpoint for its full parameter spec.
+ */
+export const listEndpointsTool = {
+    name: "list_endpoints",
+    description: "List Invoice Ninja API endpoints (slug, method, path, category, mutating, summary). " +
+        "Filter by category, read-vs-mutating, or a search term. Use this to discover which endpoint " +
+        "to call, then describe_endpoint for its parameters and call_endpoint to execute it.",
+    schema,
+    handler: async ({ params }) => {
+        const index = loadIndex();
+        let endpoints = index.endpoints;
+        const category = params?.category;
+        const mutating = params?.mutating;
+        const search = params?.search;
+        if (category) {
+            const wanted = category.toLowerCase();
+            endpoints = endpoints.filter((e) => e.category.toLowerCase() === wanted);
+        }
+        if (mutating !== undefined) {
+            endpoints = endpoints.filter((e) => e.mutating === mutating);
+        }
+        if (search) {
+            const q = search.toLowerCase();
+            endpoints = endpoints.filter((e) => e.slug.includes(q) ||
+                e.name.toLowerCase().includes(q) ||
+                e.path.toLowerCase().includes(q) ||
+                e.summary.toLowerCase().includes(q));
+        }
+        const payload = {
+            matched: endpoints.length,
+            totalEndpoints: index.endpointCount,
+            readCount: index.readCount,
+            mutatingCount: index.mutatingCount,
+            categories: index.categories,
+            endpoints: endpoints.map((e) => ({
+                endpoint_name: e.slug,
+                method: e.method,
+                path: e.path,
+                category: e.category,
+                mutating: e.mutating,
+                summary: e.summary,
+            })),
+        };
+        if ((category || search || mutating !== undefined) && endpoints.length === 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `No endpoints matched. ` +
+                            `Available categories: ${index.categories.map((c) => c.name).join(", ")}.`,
+                    },
+                ],
+            };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(payload) }] };
+    },
+};

package/dist/types/tool-response.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@nightsquawktech/invoiceninja-mcp-server",
+  "version": "0.0.1",
+  "description": "MCP server for Invoice Ninja v5 (self-hosted): generic reads + report catalog, guarded writes.",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": "./dist/index.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "COMMERCIAL.md"
+  ],
+  "scripts": {
+    "build": "tsc && shx mkdir -p dist/catalog && shx cp -r src/catalog/endpoints dist/catalog && shx cp src/catalog/index.json dist/catalog",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "generate": "node scripts/generate-catalog.mjs",
+    "catalog": "node scripts/assemble-catalog.mjs",
+    "smoke": "node scripts/smoke-test.mjs",
+    "clean": "rimraf dist"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@nightsquawktech/mcp-core": "^0.1.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "rimraf": "^6.0.1",
+    "shx": "^0.3.4",
+    "tsx": "^4.20.0",
+    "typescript": "^5.9.0",
+    "yaml": "^2.6.1"
+  },
+  "license": "AGPL-3.0-only",
+  "author": "Kevin Reyes (NightSquawk Tech) <hello@nightsquawk.tech>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NightSquawk/invoiceninja-mcp-server.git"
+  },
+  "homepage": "https://github.com/NightSquawk/invoiceninja-mcp-server#readme",
+  "bugs": {
+    "url": "https://github.com/NightSquawk/invoiceninja-mcp-server/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}