@centry-digital/bukku-mcp 1.1.0 → 2.0.0

package/build/index.js

@@ -1,52 +1,1821 @@
 #!/usr/bin/env node
-/**
- * Bukku MCP Server Entry Point
- *
- * Startup sequence:
- * 1. Validate environment variables (BUKKU_API_TOKEN, BUKKU_COMPANY_SUBDOMAIN)
- * 2. Create BukkuClient with validated env
- * 3. Validate API token via lightweight API call
- * 4. Create MCP server and register tools
- * 5. Connect via stdio transport
- * 6. Log startup to stderr
- */
+#!/usr/bin/env node
+
+// packages/mcp/src/index.ts
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { validateEnv } from "./config/env.js";
-import { BukkuClient } from "./client/bukku-client.js";
-import { registerAllTools } from "./tools/registry.js";
-import { log } from "./utils/logger.js";
-// Read package.json version dynamically
-const packageJsonPath = new URL("../package.json", import.meta.url);
-const pkg = JSON.parse(readFileSync(fileURLToPath(packageJsonPath), "utf-8"));
-/**
- * Main entry point.
- * Exits process if configuration or authentication fails.
- */
-async function main() {
-    // Step 1: Validate environment variables
-    const env = validateEnv();
-    // Step 2: Create authenticated Bukku API client
-    const client = new BukkuClient(env);
-    // Step 3: Validate API token
-    await client.validateToken();
-    // Step 4: Create MCP server
-    const server = new McpServer({
-        name: "bukku",
-        version: pkg.version,
+
+// packages/mcp/src/config/env.ts
+import { z } from "zod";
+
+// packages/core/build/utils/logger.js
+function createLogger(prefix) {
+  return (message, ...args) => {
+    console.error(`[${prefix}] ${message}`, ...args);
+  };
+}
+
+// packages/core/build/client/bukku-client.js
+import { readFile } from "node:fs/promises";
+import { basename, extname } from "node:path";
+var log = createLogger("bukku");
+var BukkuClient = class {
+  baseUrl = "https://api.bukku.my";
+  token;
+  subdomain;
+  constructor(config) {
+    this.token = config.apiToken;
+    this.subdomain = config.companySubdomain;
+  }
+  /**
+   * Build headers for all requests.
+   * CRITICAL: Never log the actual token value - use "Bearer ***" for debugging.
+   */
+  getHeaders(includeContentType = false) {
+    const headers = {
+      Authorization: `Bearer ${this.token}`,
+      "Company-Subdomain": this.subdomain,
+      Accept: "application/json"
+    };
+    if (includeContentType) {
+      headers["Content-Type"] = "application/json";
+    }
+    return headers;
+  }
+  /**
+   * Map file extensions to MIME types for common file types.
+   * Returns null for unknown extensions.
+   */
+  getMimeType(extension) {
+    const mimeMap = {
+      ".pdf": "application/pdf",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".txt": "text/plain",
+      ".csv": "text/csv",
+      ".json": "application/json",
+      ".xml": "application/xml",
+      ".zip": "application/zip"
+    };
+    return mimeMap[extension.toLowerCase()] || null;
+  }
+  /**
+   * Build URL with query parameters.
+   */
+  buildUrl(path, params) {
+    const url = new URL(path, this.baseUrl);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * GET request with optional query parameters.
+   */
+  async get(path, params) {
+    const url = this.buildUrl(path, params);
+    const response = await fetch(url, {
+      method: "GET",
+      headers: this.getHeaders()
     });
-    // Step 5: Register all tools
-    const toolCount = registerAllTools(server, client);
-    // Step 6: Connect via stdio transport
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    // Step 7: Log startup to stderr
-    log(`Bukku MCP server started (${toolCount} tools registered)`);
-}
-// Execute main and handle fatal errors
-main().catch((error) => {
-    log("Fatal error during startup:", error);
+    if (!response.ok) {
+      throw response;
+    }
+    return response.json();
+  }
+  /**
+   * POST request with JSON body.
+   */
+  async post(path, body) {
+    const url = this.buildUrl(path);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: this.getHeaders(true),
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw response;
+    }
+    return response.json();
+  }
+  /**
+   * PUT request with JSON body.
+   */
+  async put(path, body) {
+    const url = this.buildUrl(path);
+    const response = await fetch(url, {
+      method: "PUT",
+      headers: this.getHeaders(true),
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw response;
+    }
+    return response.json();
+  }
+  /**
+   * PATCH request with JSON body (for status updates).
+   */
+  async patch(path, body) {
+    const url = this.buildUrl(path);
+    const response = await fetch(url, {
+      method: "PATCH",
+      headers: this.getHeaders(true),
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw response;
+    }
+    return response.json();
+  }
+  /**
+   * DELETE request.
+   */
+  async delete(path) {
+    const url = this.buildUrl(path);
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: this.getHeaders()
+    });
+    if (!response.ok) {
+      throw response;
+    }
+  }
+  /**
+   * POST multipart/form-data request for file uploads.
+   * Reads file from disk and sends as multipart form data.
+   * CRITICAL: Does NOT manually set Content-Type - fetch sets it automatically with boundary.
+   *
+   * @param path - API endpoint path
+   * @param filePath - Absolute path to file on disk
+   * @returns API response
+   */
+  async postMultipart(path, filePath) {
+    const url = this.buildUrl(path);
+    const fileBuffer = await readFile(filePath);
+    const fileName = basename(filePath);
+    const fileExtension = extname(filePath);
+    const mimeType = this.getMimeType(fileExtension) || "application/octet-stream";
+    const file = new File([fileBuffer], fileName, { type: mimeType });
+    const form = new FormData();
+    form.append("file", file);
+    const headers = this.getHeaders(false);
+    const response = await fetch(url, {
+      method: "POST",
+      headers,
+      body: form
+    });
+    if (!response.ok) {
+      throw response;
+    }
+    return response.json();
+  }
+  /**
+   * Validate token on startup by making a lightweight API call.
+   * Uses GET /contacts with page_size=1 to verify authentication.
+   * Exits process if token is invalid (401).
+   */
+  async validateToken() {
+    try {
+      await this.get("/contacts", { page_size: 1 });
+      log("Token validated successfully");
+    } catch (error) {
+      if (error instanceof Response && error.status === 401) {
+        log("Authentication Error\n");
+        log("The provided BUKKU_API_TOKEN is invalid or expired.\n");
+        log("Please check:");
+        log("  1. Token is copied correctly (no extra spaces)");
+        log("  2. API Access is enabled in Bukku Control Panel -> Integrations");
+        log("  3. Token has not been revoked or regenerated\n");
+        process.exit(1);
+      }
+      log("Failed to validate token:", error);
+      process.exit(1);
+    }
+  }
+};
+
+// packages/core/build/errors/transform.js
+function transformHttpError(status, body, operation) {
+  if (status === 401) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `Bukku authentication failed for "${operation}". The BUKKU_API_TOKEN environment variable is either missing or invalid. Please check your token and restart the server with the correct credentials.`
+        }
+      ]
+    };
+  }
+  if (status === 403) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `You don't have permission to "${operation}". Please check your Bukku account permissions and ensure you have access to this resource.`
+        }
+      ]
+    };
+  }
+  if (status === 404) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `I couldn't find that item when trying to "${operation}". Try listing the available items first to see what's accessible.`
+        }
+      ]
+    };
+  }
+  if (status === 400 || status === 422) {
+    const parsedBody = body;
+    const errors = parsedBody?.errors;
+    if (errors && typeof errors === "object") {
+      const errorMessages = Object.entries(errors).map(([field, messages]) => `  - ${field}: ${messages.join(", ")}`).join("\n");
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `Validation failed for "${operation}":
+${errorMessages}
+
+Please fix these issues and try again.`
+          }
+        ]
+      };
+    } else {
+      const message = parsedBody?.message || "Invalid request";
+      return {
+        isError: true,
+        content: [
+          {
+            type: "text",
+            text: `${message} when trying to "${operation}". Please check your input and try again.`
+          }
+        ]
+      };
+    }
+  }
+  if (status === 503) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `Bukku is temporarily unavailable while trying to "${operation}". Please try again in a few moments.`
+        }
+      ]
+    };
+  }
+  if (status !== null && status >= 500) {
+    const parsedBody = body;
+    const bodyText = body ? `
+
+Server response: ${JSON.stringify(parsedBody, null, 2)}` : "";
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `An unexpected error occurred on Bukku's servers while trying to "${operation}". Please try again, and if the issue persists, contact Bukku support.${bodyText}`
+        }
+      ]
+    };
+  }
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: `An error occurred while trying to "${operation}". Please check your request and try again.`
+      }
+    ]
+  };
+}
+function transformNetworkError(error, operation) {
+  const errorMessage = error instanceof Error ? error.message : String(error);
+  if (errorMessage.includes("fetch") || errorMessage.includes("connect") || errorMessage.includes("network") || error instanceof TypeError) {
+    return {
+      isError: true,
+      content: [
+        {
+          type: "text",
+          text: `Couldn't connect to Bukku while trying to "${operation}". Please check your internet connection and ensure the Bukku API is accessible.`
+        }
+      ]
+    };
+  }
+  return {
+    isError: true,
+    content: [
+      {
+        type: "text",
+        text: `An unexpected error occurred while trying to "${operation}": ${errorMessage}. Please try again.`
+      }
+    ]
+  };
+}
+
+// packages/core/build/validation/double-entry.js
+function validateDoubleEntry(lines, minLines = 2) {
+  if (lines.length < minLines) {
+    const lineWord = lines.length === 1 ? "line" : "lines";
+    return {
+      valid: false,
+      error: `Journal entries require at least ${minLines} line items (minimum one debit and one credit). This entry has ${lines.length} ${lineWord}.`
+    };
+  }
+  let totalDebits = 0;
+  let totalCredits = 0;
+  for (const line of lines) {
+    totalDebits += line.debit_amount || 0;
+    totalCredits += line.credit_amount || 0;
+  }
+  const difference = Math.abs(totalDebits - totalCredits);
+  const EPSILON = 0.01;
+  if (difference >= EPSILON) {
+    return {
+      valid: false,
+      error: `Journal entry is unbalanced. Total debits: ${totalDebits.toFixed(2)}, Total credits: ${totalCredits.toFixed(2)}. Difference: ${difference.toFixed(2)}. Debits must equal credits in double-entry accounting.`
+    };
+  }
+  return { valid: true };
+}
+
+// packages/core/build/cache/reference-cache.js
+var ReferenceDataCache = class {
+  cache = /* @__PURE__ */ new Map();
+  ttlMs;
+  /**
+   * Create a new reference data cache
+   * @param ttlMs Time-to-live in milliseconds (default: 5 minutes)
+   */
+  constructor(ttlMs = 5 * 60 * 1e3) {
+    this.ttlMs = ttlMs;
+  }
+  /**
+   * Get cached data by key
+   * @param key Cache key (reference data type name)
+   * @returns Cached data or undefined if not found or expired
+   */
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry)
+      return void 0;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    return entry.data;
+  }
+  /**
+   * Store data in cache with TTL
+   * @param key Cache key (reference data type name)
+   * @param data Data to cache
+   */
+  set(key, data) {
+    this.cache.set(key, {
+      data,
+      expiresAt: Date.now() + this.ttlMs
+    });
+  }
+  /**
+   * Invalidate a specific cache entry
+   * @param key Cache key to invalidate
+   */
+  invalidate(key) {
+    this.cache.delete(key);
+  }
+  /**
+   * Clear all cached entries
+   */
+  clear() {
+    this.cache.clear();
+  }
+};
+
+// packages/core/build/entities/sales-invoice.js
+var salesInvoiceConfig = {
+  entity: "sales-invoice",
+  apiBasePath: "/sales/invoices",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "sales invoice",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "email_status", "transfer_status", "payment_status"],
+  businessRules: {
+    delete: "Only draft and void invoices can be deleted. Ready or pending approval invoices cannot be deleted \u2014 use update-sales-invoice-status to void a ready invoice instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void invoice is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "sales"
+};
+
+// packages/core/build/entities/sales-quote.js
+var salesQuoteConfig = {
+  entity: "sales-quote",
+  apiBasePath: "/sales/quotes",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "sales quote",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "email_status", "transfer_status"],
+  businessRules: {
+    delete: "Only draft and void quotes can be deleted. Ready or pending approval quotes cannot be deleted \u2014 use update-sales-quote-status to void a ready quote instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void quote is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "sales"
+};
+
+// packages/core/build/entities/sales-order.js
+var salesOrderConfig = {
+  entity: "sales-order",
+  apiBasePath: "/sales/orders",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "sales order",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "email_status", "transfer_status"],
+  businessRules: {
+    delete: "Only draft and void orders can be deleted. Ready or pending approval orders cannot be deleted \u2014 use update-sales-order-status to void a ready order instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void order is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "sales"
+};
+
+// packages/core/build/entities/sales-credit-note.js
+var salesCreditNoteConfig = {
+  entity: "sales-credit-note",
+  apiBasePath: "/sales/credit_notes",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "sales credit note",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "email_status"],
+  businessRules: {
+    delete: "Only draft and void credit notes can be deleted. Ready or pending approval credit notes cannot be deleted \u2014 use update-sales-credit-note-status to void a ready credit note instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void credit note is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "sales"
+};
+
+// packages/core/build/entities/sales-payment.js
+var salesPaymentConfig = {
+  entity: "sales-payment",
+  apiBasePath: "/sales/payments",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "sales payment",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "payment_mode"],
+  businessRules: {
+    delete: "Only draft and void payments can be deleted. Ready or pending approval payments cannot be deleted \u2014 use update-sales-payment-status to void a ready payment instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void payment is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "sales"
+};
+
+// packages/core/build/entities/sales-refund.js
+var salesRefundConfig = {
+  entity: "sales-refund",
+  apiBasePath: "/sales/refunds",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "sales refund",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id"],
+  businessRules: {
+    delete: "Only draft and void refunds can be deleted. Ready or pending approval refunds cannot be deleted \u2014 use update-sales-refund-status to void a ready refund instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void refund is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "sales"
+};
+
+// packages/core/build/entities/delivery-order.js
+var deliveryOrderConfig = {
+  entity: "delivery-order",
+  apiBasePath: "/sales/delivery_orders",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "delivery order",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "email_status", "transfer_status"],
+  businessRules: {
+    delete: "Only draft and void delivery orders can be deleted. Ready or pending approval delivery orders cannot be deleted \u2014 use update-delivery-order-status to void a ready delivery order instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void delivery order is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "sales"
+};
+
+// packages/core/build/entities/purchase-order.js
+var purchaseOrderConfig = {
+  entity: "purchase-order",
+  apiBasePath: "/purchases/orders",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "purchase order",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "email_status", "transfer_status"],
+  businessRules: {
+    delete: "Only draft and void purchase orders can be deleted. Ready or pending approval purchase orders cannot be deleted \u2014 use update-purchase-order-status to void a ready purchase order instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void purchase order is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "purchases"
+};
+
+// packages/core/build/entities/purchase-bill.js
+var purchaseBillConfig = {
+  entity: "purchase-bill",
+  apiBasePath: "/purchases/bills",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "purchase bill",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "payment_status", "payment_mode"],
+  businessRules: {
+    delete: "Only draft and void bills can be deleted. Ready or pending approval bills cannot be deleted \u2014 use update-purchase-bill-status to void a ready bill instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void bill is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "purchases"
+};
+
+// packages/core/build/entities/purchase-credit-note.js
+var purchaseCreditNoteConfig = {
+  entity: "purchase-credit-note",
+  apiBasePath: "/purchases/credit_notes",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "purchase credit note",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "payment_status"],
+  businessRules: {
+    delete: "Only draft and void credit notes can be deleted. Ready or pending approval credit notes cannot be deleted \u2014 use update-purchase-credit-note-status to void a ready credit note instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void credit note is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "purchases"
+};
+
+// packages/core/build/entities/purchase-payment.js
+var purchasePaymentConfig = {
+  entity: "purchase-payment",
+  apiBasePath: "/purchases/payments",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "purchase payment",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "email_status", "payment_status", "account_id"],
+  businessRules: {
+    delete: "Only draft and void payments can be deleted. Ready or pending approval payments cannot be deleted \u2014 use update-purchase-payment-status to void a ready payment instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void payment is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "purchases"
+};
+
+// packages/core/build/entities/purchase-refund.js
+var purchaseRefundConfig = {
+  entity: "purchase-refund",
+  apiBasePath: "/purchases/refunds",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "purchase refund",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "email_status", "payment_status", "account_id"],
+  businessRules: {
+    delete: "Only draft and void refunds can be deleted. Ready or pending approval refunds cannot be deleted \u2014 use update-purchase-refund-status to void a ready refund instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void refund is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "purchases"
+};
+
+// packages/core/build/entities/goods-received-note.js
+var goodsReceivedNoteConfig = {
+  entity: "goods-received-note",
+  apiBasePath: "/purchases/goods_received_notes",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "goods received note",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "email_status", "transfer_status"],
+  businessRules: {
+    delete: "Only draft and void goods received notes can be deleted. Ready or pending approval goods received notes cannot be deleted \u2014 use update-goods-received-note-status to void a ready goods received note instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void goods received note is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "purchases"
+};
+
+// packages/core/build/entities/bank-money-in.js
+var bankMoneyInConfig = {
+  entity: "bank-money-in",
+  apiBasePath: "/banking/incomes",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "bank money in transaction",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "account_id", "email_status"],
+  businessRules: {
+    delete: "Only draft and void money in transactions can be deleted. Ready or pending approval transactions cannot be deleted \u2014 use update-bank-money-in-status to void a ready transaction instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void transaction is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "banking"
+};
+
+// packages/core/build/entities/bank-money-out.js
+var bankMoneyOutConfig = {
+  entity: "bank-money-out",
+  apiBasePath: "/banking/expenses",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "bank money out transaction",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["contact_id", "account_id", "email_status"],
+  businessRules: {
+    delete: "Only draft and void money out transactions can be deleted. Ready or pending approval transactions cannot be deleted \u2014 use update-bank-money-out-status to void a ready transaction instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void transaction is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "banking"
+};
+
+// packages/core/build/entities/bank-transfer.js
+var bankTransferConfig = {
+  entity: "bank-transfer",
+  apiBasePath: "/banking/transfers",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "bank transfer",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: true,
+  listFilters: ["account_id"],
+  businessRules: {
+    delete: "Only draft and void transfers can be deleted. Ready or pending approval transfers cannot be deleted \u2014 use update-bank-transfer-status to void a ready transfer instead.",
+    statusTransitions: "Valid transitions: draft -> pending_approval, draft -> ready, pending_approval -> ready, ready -> void. A void transfer is final and cannot be changed. There is no way to revert from ready, pending_approval, or void back to draft."
+  },
+  cliGroup: "banking"
+};
+
+// packages/core/build/entities/contact.js
+var contactConfig = {
+  entity: "contact",
+  apiBasePath: "/contacts",
+  singularKey: "contact",
+  pluralKey: "contacts",
+  description: "contact",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: false,
+  listFilters: ["group_id", "status", "type", "is_myinvois_ready"],
+  businessRules: {
+    delete: "Only contacts with no linked transactions can be deleted. Archive instead if the contact has transaction history."
+  },
+  cliGroup: "contacts"
+};
+
+// packages/core/build/entities/contact-group.js
+var contactGroupConfig = {
+  entity: "contact-group",
+  apiBasePath: "/contacts/groups",
+  singularKey: "group",
+  pluralKey: "groups",
+  description: "contact group",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: false,
+  listFilters: [],
+  cliGroup: "contacts"
+};
+
+// packages/core/build/entities/product.js
+var productConfig = {
+  entity: "product",
+  apiBasePath: "/products",
+  singularKey: "product",
+  pluralKey: "products",
+  description: "product. Use list-tax-codes to find valid tax code IDs for sale_tax_code_id and purchase_tax_code_id. Use list-accounts to find valid account IDs for sale_account_id, purchase_account_id, and inventory_account_id. Use list-product-groups to find group IDs for group_ids.",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: false,
+  listFilters: ["search", "stock_level", "mode", "type", "include_archived"],
+  businessRules: {
+    delete: "Only products that are not used in any transactions can be deleted. Archive instead if the product has transaction history."
+  },
+  cliGroup: "products"
+};
+
+// packages/core/build/entities/product-bundle.js
+var productBundleConfig = {
+  entity: "product-bundle",
+  apiBasePath: "/products/bundles",
+  singularKey: "bundle",
+  pluralKey: "bundles",
+  description: "product bundle. Bundles aggregate multiple products with optional discounts. To list bundles, use list-products with type=bundle. Use list-products to find product IDs for bundle items.",
+  operations: ["get", "create", "update", "delete"],
+  hasStatusUpdate: false,
+  listFilters: [],
+  businessRules: {
+    delete: "Only bundles that are not used in any transactions can be deleted."
+  },
+  cliGroup: "products"
+};
+
+// packages/core/build/entities/product-group.js
+var productGroupConfig = {
+  entity: "product-group",
+  apiBasePath: "/products/groups",
+  singularKey: "group",
+  pluralKey: "groups",
+  description: "product group. Groups organize products into categories. Use list-products to find product IDs for the product_ids array.",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: false,
+  listFilters: [],
+  cliGroup: "products"
+};
+
+// packages/core/build/entities/journal-entry.js
+var journalEntryConfig = {
+  entity: "journal-entry",
+  apiBasePath: "/journal_entries",
+  singularKey: "transaction",
+  pluralKey: "transactions",
+  description: "journal entry",
+  operations: ["list", "get", "delete"],
+  hasStatusUpdate: true,
+  listFilters: [],
+  businessRules: {
+    delete: "Only draft and void journal entries can be deleted. Ready journal entries cannot be deleted -- use update-journal-entry-status to void a ready entry instead.",
+    statusTransitions: "Valid transitions: draft -> ready, ready -> void. A void entry is final and cannot be changed."
+  },
+  cliGroup: "accounting"
+};
+
+// packages/core/build/entities/account.js
+var accountConfig = {
+  entity: "account",
+  apiBasePath: "/accounts",
+  singularKey: "account",
+  pluralKey: "accounts",
+  description: "account",
+  operations: ["get", "create", "update", "delete"],
+  hasStatusUpdate: false,
+  listFilters: [],
+  businessRules: {
+    delete: "Only accounts that are not assigned to locked system type, have no children, and are not used in transactions can be deleted. Use archive-account instead if the account has transaction history."
+  },
+  cliGroup: "accounting"
+};
+
+// packages/core/build/entities/file.js
+var fileConfig = {
+  entity: "file",
+  apiBasePath: "/files",
+  singularKey: "file",
+  pluralKey: "files",
+  description: "file. Files are typically attached to sales and purchase transactions using file_ids arrays. Use upload-file to add new files.",
+  operations: ["list", "get"],
+  hasStatusUpdate: false,
+  listFilters: [],
+  cliGroup: "files"
+};
+
+// packages/core/build/entities/location.js
+var locationConfig = {
+  entity: "location",
+  apiBasePath: "/locations",
+  singularKey: "location",
+  pluralKey: "locations",
+  description: "location for multi-branch accounting. Use locations to track which branch or office a transaction belongs to.",
+  operations: ["list", "create"],
+  hasStatusUpdate: false,
+  listFilters: ["include_archived"],
+  cliGroup: "control-panel"
+};
+
+// packages/core/build/entities/tag.js
+var tagConfig = {
+  entity: "tag",
+  apiBasePath: "/tags",
+  singularKey: "tag",
+  pluralKey: "tags",
+  description: "tag for categorizing transactions and documents. Tags must belong to a tag group \u2014 use list-tag-groups to find available groups and their tag_group_id before creating a tag.",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: false,
+  listFilters: [],
+  businessRules: {
+    delete: "API may restrict deletion if tag is referenced by transactions. Archive the tag instead if deletion fails."
+  },
+  cliGroup: "control-panel"
+};
+
+// packages/core/build/entities/tag-group.js
+var tagGroupConfig = {
+  entity: "tag-group",
+  apiBasePath: "/tags/groups",
+  singularKey: "tag_group",
+  pluralKey: "tag_groups",
+  description: "tag group for organizing tags into categories. Tag groups contain tags as children \u2014 the list response includes nested tag arrays for each group.",
+  operations: ["list", "get", "create", "update", "delete"],
+  hasStatusUpdate: false,
+  listFilters: ["include_archived"],
+  businessRules: {
+    delete: "API may restrict deletion if tag group contains tags or is referenced by transactions. Archive instead, or manually delete child tags first."
+  },
+  cliGroup: "control-panel"
+};
+
+// packages/mcp/src/config/env.ts
+var log2 = createLogger("bukku-mcp");
+var envSchema = z.object({
+  BUKKU_API_TOKEN: z.string().min(1, "BUKKU_API_TOKEN is required"),
+  BUKKU_COMPANY_SUBDOMAIN: z.string().min(1, "BUKKU_COMPANY_SUBDOMAIN is required")
+});
+function validateEnv() {
+  const result = envSchema.safeParse(process.env);
+  if (!result.success) {
+    log2("Configuration Error\n");
+    log2("Missing required environment variables:");
+    for (const issue of result.error.issues) {
+      log2(`  - ${issue.path.join(".")}: ${issue.message}`);
+    }
+    log2("\nSetup checklist:");
+    log2("  1. Go to Bukku web app -> Control Panel -> Integrations");
+    log2("  2. Turn on API Access and copy the Access Token");
+    log2("  3. Set BUKKU_API_TOKEN=<your-token>");
+    log2("  4. Set BUKKU_COMPANY_SUBDOMAIN=<your-subdomain>");
+    log2("     (e.g., 'mycompany' from mycompany.bukku.my)");
+    log2("  5. Restart Claude Desktop\n");
     process.exit(1);
+  }
+  return result.data;
+}
+
+// packages/mcp/src/tools/factory.ts
+import { z as z2 } from "zod";
+var log3 = createLogger("bukku-mcp");
+function registerCrudTools(server, client, config) {
+  let toolCount = 0;
+  if (config.operations.includes("list")) {
+    const listName = `list-${config.entity}s`;
+    const listDescription = `List ${config.description}s with optional filters`;
+    const listSchema = {
+      page: z2.number().optional().describe("Page number for pagination"),
+      page_size: z2.number().optional().describe("Number of items per page"),
+      search: z2.string().optional().describe("Search query"),
+      date_from: z2.string().optional().describe("Filter by start date (YYYY-MM-DD)"),
+      date_to: z2.string().optional().describe("Filter by end date (YYYY-MM-DD)"),
+      status: z2.string().optional().describe("Filter by status"),
+      sort_by: z2.string().optional().describe("Field to sort by"),
+      sort_dir: z2.enum(["asc", "desc"]).optional().describe("Sort direction")
+    };
+    if (config.listFilters) {
+      for (const filter of config.listFilters) {
+        listSchema[filter] = z2.string().optional().describe(`Filter by ${filter}`);
+      }
+    }
+    server.tool(
+      listName,
+      listDescription,
+      listSchema,
+      async (params) => {
+        try {
+          const result = await client.get(config.apiBasePath, params);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+              }
+            ]
+          };
+        } catch (error) {
+          if (error instanceof Response) {
+            const body = await error.json().catch(() => null);
+            return transformHttpError(error.status, body, listName);
+          }
+          return transformNetworkError(error, listName);
+        }
+      }
+    );
+    toolCount++;
+    log3(`Registered tool: ${listName}`);
+  }
+  if (config.operations.includes("get")) {
+    const getName = `get-${config.entity}`;
+    const getDescription = `Get a ${config.description} by ID`;
+    server.tool(
+      getName,
+      getDescription,
+      {
+        id: z2.number().describe(`The ${config.description} ID`)
+      },
+      async (params) => {
+        try {
+          const result = await client.get(`${config.apiBasePath}/${params.id}`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+              }
+            ]
+          };
+        } catch (error) {
+          if (error instanceof Response) {
+            const body = await error.json().catch(() => null);
+            return transformHttpError(error.status, body, getName);
+          }
+          return transformNetworkError(error, getName);
+        }
+      }
+    );
+    toolCount++;
+    log3(`Registered tool: ${getName}`);
+  }
+  if (config.operations.includes("create")) {
+    const createName = `create-${config.entity}`;
+    const createDescription = `Create a new ${config.description}`;
+    server.tool(
+      createName,
+      createDescription,
+      {
+        data: z2.record(z2.string(), z2.unknown()).describe("Data for the new item")
+      },
+      async (params) => {
+        try {
+          const result = await client.post(config.apiBasePath, params.data);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+              }
+            ]
+          };
+        } catch (error) {
+          if (error instanceof Response) {
+            const body = await error.json().catch(() => null);
+            return transformHttpError(error.status, body, createName);
+          }
+          return transformNetworkError(error, createName);
+        }
+      }
+    );
+    toolCount++;
+    log3(`Registered tool: ${createName}`);
+  }
+  if (config.operations.includes("update")) {
+    const updateName = `update-${config.entity}`;
+    const updateDescription = `Update an existing ${config.description}`;
+    server.tool(
+      updateName,
+      updateDescription,
+      {
+        id: z2.number().describe(`The ${config.description} ID`),
+        data: z2.record(z2.string(), z2.unknown()).describe("Updated data")
+      },
+      async (params) => {
+        try {
+          const result = await client.put(`${config.apiBasePath}/${params.id}`, params.data);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+              }
+            ]
+          };
+        } catch (error) {
+          if (error instanceof Response) {
+            const body = await error.json().catch(() => null);
+            return transformHttpError(error.status, body, updateName);
+          }
+          return transformNetworkError(error, updateName);
+        }
+      }
+    );
+    toolCount++;
+    log3(`Registered tool: ${updateName}`);
+  }
+  if (config.operations.includes("delete")) {
+    const deleteName = `delete-${config.entity}`;
+    const deleteDescription = `Delete a ${config.description}. ${config.businessRules?.delete ?? ""}`.trim();
+    server.tool(
+      deleteName,
+      deleteDescription,
+      {
+        id: z2.number().describe(`The ${config.description} ID`)
+      },
+      async (params) => {
+        try {
+          await client.delete(`${config.apiBasePath}/${params.id}`);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Successfully deleted ${config.description} with ID ${params.id}`
+              }
+            ]
+          };
+        } catch (error) {
+          if (error instanceof Response) {
+            const body = await error.json().catch(() => null);
+            return transformHttpError(error.status, body, deleteName);
+          }
+          return transformNetworkError(error, deleteName);
+        }
+      }
+    );
+    toolCount++;
+    log3(`Registered tool: ${deleteName}`);
+  }
+  if (config.hasStatusUpdate) {
+    const statusName = `update-${config.entity}-status`;
+    const statusDescription = `Update the status of a ${config.description}. ${config.businessRules?.statusTransitions ?? ""}`.trim();
+    server.tool(
+      statusName,
+      statusDescription,
+      {
+        id: z2.number().describe(`The ${config.description} ID`),
+        status: z2.string().describe("New status value")
+      },
+      async (params) => {
+        try {
+          const result = await client.patch(`${config.apiBasePath}/${params.id}`, {
+            status: params.status
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+              }
+            ]
+          };
+        } catch (error) {
+          if (error instanceof Response) {
+            const body = await error.json().catch(() => null);
+            return transformHttpError(error.status, body, statusName);
+          }
+          return transformNetworkError(error, statusName);
+        }
+      }
+    );
+    toolCount++;
+    log3(`Registered tool: ${statusName}`);
+  }
+  return toolCount;
+}
+
+// packages/mcp/src/tools/custom/contact-archive.ts
+import { z as z3 } from "zod";
+var log4 = createLogger("bukku-mcp");
+function registerContactArchiveTools(server, client) {
+  server.tool(
+    "archive-contact",
+    "Archive a contact (hide from active lists). Use this for contacts with transaction history instead of deleting them.",
+    {
+      id: z3.number().describe("The contact ID")
+    },
+    async (params) => {
+      try {
+        const result = await client.patch(`/contacts/${params.id}`, {
+          is_archived: true
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "archive-contact");
+        }
+        return transformNetworkError(error, "archive-contact");
+      }
+    }
+  );
+  log4("Registered tool: archive-contact");
+  server.tool(
+    "unarchive-contact",
+    "Unarchive a contact (restore to active lists).",
+    {
+      id: z3.number().describe("The contact ID")
+    },
+    async (params) => {
+      try {
+        const result = await client.patch(`/contacts/${params.id}`, {
+          is_archived: false
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "unarchive-contact");
+        }
+        return transformNetworkError(error, "unarchive-contact");
+      }
+    }
+  );
+  log4("Registered tool: unarchive-contact");
+  return 2;
+}
+
+// packages/mcp/src/tools/custom/product-archive.ts
+import { z as z4 } from "zod";
+var log5 = createLogger("bukku-mcp");
+function registerProductArchiveTools(server, client) {
+  server.tool(
+    "archive-product",
+    "Archive a product (hide from active lists). Use this for products with transaction history instead of deleting them.",
+    {
+      id: z4.number().describe("The product ID")
+    },
+    async (params) => {
+      try {
+        const result = await client.patch(`/products/${params.id}`, {
+          is_archived: true
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "archive-product");
+        }
+        return transformNetworkError(error, "archive-product");
+      }
+    }
+  );
+  log5("Registered tool: archive-product");
+  server.tool(
+    "unarchive-product",
+    "Unarchive a product (restore to active lists).",
+    {
+      id: z4.number().describe("The product ID")
+    },
+    async (params) => {
+      try {
+        const result = await client.patch(`/products/${params.id}`, {
+          is_archived: false
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "unarchive-product");
+        }
+        return transformNetworkError(error, "unarchive-product");
+      }
+    }
+  );
+  log5("Registered tool: unarchive-product");
+  server.tool(
+    "archive-product-bundle",
+    "Archive a product bundle (hide from active lists). Use this for bundles with transaction history instead of deleting them.",
+    {
+      id: z4.number().describe("The product bundle ID")
+    },
+    async (params) => {
+      try {
+        const result = await client.patch(`/products/bundles/${params.id}`, {
+          is_archived: true
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "archive-product-bundle");
+        }
+        return transformNetworkError(error, "archive-product-bundle");
+      }
+    }
+  );
+  log5("Registered tool: archive-product-bundle");
+  server.tool(
+    "unarchive-product-bundle",
+    "Unarchive a product bundle (restore to active lists).",
+    {
+      id: z4.number().describe("The product bundle ID")
+    },
+    async (params) => {
+      try {
+        const result = await client.patch(`/products/bundles/${params.id}`, {
+          is_archived: false
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "unarchive-product-bundle");
+        }
+        return transformNetworkError(error, "unarchive-product-bundle");
+      }
+    }
+  );
+  log5("Registered tool: unarchive-product-bundle");
+  return 4;
+}
+
+// packages/mcp/src/tools/custom/reference-data.ts
+var log6 = createLogger("bukku-mcp");
+var REFERENCE_TYPES = [
+  {
+    type: "tax_codes",
+    toolName: "list-tax-codes",
+    description: "List all tax codes (tax rate definitions for invoices and purchases). Use to find valid tax_code_id values before creating sales invoices, purchase bills, or products."
+  },
+  {
+    type: "currencies",
+    toolName: "list-currencies",
+    description: "List all activated currencies. Use to find valid currency_code values for multi-currency transactions."
+  },
+  {
+    type: "payment_methods",
+    toolName: "list-payment-methods",
+    description: "List all payment methods (e.g., Bank Transfer, Cash, Credit Card). Use to find valid payment_method_id values for payments and refunds."
+  },
+  {
+    type: "terms",
+    toolName: "list-terms",
+    description: "List all payment terms (e.g., Net 30, Due on Receipt). Use to find valid term_id values when creating invoices or bills."
+  },
+  {
+    type: "accounts",
+    toolName: "list-accounts",
+    description: "List all accounts from the chart of accounts. Use to find valid account IDs for sale_account_id, purchase_account_id, and inventory_account_id in products, and for journal entries."
+  },
+  {
+    type: "price_levels",
+    toolName: "list-price-levels",
+    description: "List all price levels (custom pricing tiers for volume discounts). Use to find valid price_level_id values for product custom pricing."
+  },
+  {
+    type: "countries",
+    toolName: "list-countries",
+    description: "List all countries ordered by name. Use to find valid country codes for contacts and locations."
+  },
+  {
+    type: "classification_code_list",
+    toolName: "list-classification-codes",
+    description: "List all product classification codes (Malaysia LHDN e-Invoice). Use to find valid classification_code values for products."
+  },
+  {
+    type: "numberings",
+    toolName: "list-numberings",
+    description: "List all document numbering schemes. Use to find valid numbering IDs for transactions."
+  },
+  {
+    type: "state_list",
+    toolName: "list-states",
+    description: "List all geographic states/provinces for addresses."
+  }
+];
+function registerReferenceDataTools(server, client, cache) {
+  for (const { type, toolName, description } of REFERENCE_TYPES) {
+    server.tool(
+      toolName,
+      description,
+      {},
+      async () => {
+        const cached = cache.get(type);
+        if (cached) {
+          return {
+            content: [{ type: "text", text: JSON.stringify(cached, null, 2) }]
+          };
+        }
+        try {
+          const result = await client.post("/v2/lists", {
+            lists: [type],
+            params: []
+          });
+          cache.set(type, result);
+          return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+          };
+        } catch (error) {
+          if (error instanceof Response) {
+            const body = await error.json().catch(() => null);
+            return transformHttpError(error.status, body, toolName);
+          }
+          return transformNetworkError(error, toolName);
+        }
+      }
+    );
+    log6(`Registered tool: ${toolName}`);
+  }
+  return REFERENCE_TYPES.length;
+}
+
+// packages/mcp/src/tools/custom/journal-entry-tools.ts
+import { z as z5 } from "zod";
+var log7 = createLogger("bukku-mcp");
+function registerJournalEntryTools(server, client) {
+  server.tool(
+    "create-journal-entry",
+    "Create a new journal entry. Use list-accounts to find valid account IDs for line items. Journal entries must have balanced debits and credits (total debits = total credits).",
+    {
+      data: z5.record(z5.string(), z5.unknown()).describe("Journal entry data including journal_items array with debit/credit amounts and account IDs")
+    },
+    async (params) => {
+      try {
+        const journalItems = params.data.journal_items;
+        if (journalItems && Array.isArray(journalItems)) {
+          const validation = validateDoubleEntry(journalItems);
+          if (!validation.valid) {
+            return {
+              isError: true,
+              content: [
+                {
+                  type: "text",
+                  text: validation.error
+                }
+              ]
+            };
+          }
+        }
+        const result = await client.post("/journal_entries", params.data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "create-journal-entry");
+        }
+        return transformNetworkError(error, "create-journal-entry");
+      }
+    }
+  );
+  log7("Registered tool: create-journal-entry");
+  server.tool(
+    "update-journal-entry",
+    "Update an existing journal entry. If updating line items, journal entries must have balanced debits and credits (total debits = total credits).",
+    {
+      id: z5.number().describe("The journal entry ID"),
+      data: z5.record(z5.string(), z5.unknown()).describe("Updated journal entry data")
+    },
+    async (params) => {
+      try {
+        const journalItems = params.data.journal_items;
+        if (journalItems && Array.isArray(journalItems)) {
+          const validation = validateDoubleEntry(journalItems);
+          if (!validation.valid) {
+            return {
+              isError: true,
+              content: [
+                {
+                  type: "text",
+                  text: validation.error
+                }
+              ]
+            };
+          }
+        }
+        const result = await client.put(`/journal_entries/${params.id}`, params.data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "update-journal-entry");
+        }
+        return transformNetworkError(error, "update-journal-entry");
+      }
+    }
+  );
+  log7("Registered tool: update-journal-entry");
+  return 2;
+}
+
+// packages/mcp/src/tools/custom/account-tools.ts
+import { z as z6 } from "zod";
+var log8 = createLogger("bukku-mcp");
+function registerAccountCustomTools(server, client) {
+  server.tool(
+    "search-accounts",
+    "Search and filter accounts from the chart of accounts. Supports filtering by category and archived status. For a quick cached account lookup (e.g., to find account IDs for journal entries), use list-accounts instead.",
+    {
+      search: z6.string().optional().describe("Search by account name, code, or description"),
+      category: z6.enum(["assets", "liabilities", "equity", "income", "expenses"]).optional().describe("Filter by account category"),
+      is_archived: z6.boolean().optional().describe("Filter by archived status (default: false, showing only active accounts)"),
+      sort_by: z6.enum(["code", "name", "balance"]).optional().describe("Sort field (default: code)"),
+      sort_dir: z6.enum(["asc", "desc"]).optional().describe("Sort direction (default: asc)"),
+      page: z6.number().optional().describe("Page number for pagination"),
+      page_size: z6.number().optional().describe("Number of items per page")
+    },
+    async (params) => {
+      try {
+        const queryParams = {
+          search: params.search,
+          category: params.category,
+          sort_by: params.sort_by,
+          sort_dir: params.sort_dir,
+          page: params.page,
+          page_size: params.page_size
+        };
+        if (params.is_archived !== void 0) {
+          queryParams.is_archived = params.is_archived ? "true" : "false";
+        }
+        const result = await client.get("/accounts", queryParams);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "search-accounts");
+        }
+        return transformNetworkError(error, "search-accounts");
+      }
+    }
+  );
+  log8("Registered tool: search-accounts");
+  server.tool(
+    "archive-account",
+    "Archive an account (hide from active lists). Use this instead of delete for accounts with transaction history. Archived accounts are hidden by default but can be reactivated.",
+    {
+      id: z6.number().describe("The account ID")
+    },
+    async (params) => {
+      try {
+        const result = await client.patch(`/accounts/${params.id}`, {
+          is_archived: true
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "archive-account");
+        }
+        return transformNetworkError(error, "archive-account");
+      }
+    }
+  );
+  log8("Registered tool: archive-account");
+  server.tool(
+    "unarchive-account",
+    "Unarchive an account (restore to active lists).",
+    {
+      id: z6.number().describe("The account ID")
+    },
+    async (params) => {
+      try {
+        const result = await client.patch(`/accounts/${params.id}`, {
+          is_archived: false
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "unarchive-account");
+        }
+        return transformNetworkError(error, "unarchive-account");
+      }
+    }
+  );
+  log8("Registered tool: unarchive-account");
+  return 3;
+}
+
+// packages/mcp/src/tools/custom/file-upload.ts
+import { z as z7 } from "zod";
+var log9 = createLogger("bukku-mcp");
+function registerFileUploadTool(server, client) {
+  server.tool(
+    "upload-file",
+    "Upload a file to Bukku. Returns file object with id, url, and metadata. Use the returned file id in transaction file_ids arrays to attach files to sales invoices, purchase bills, and other documents.",
+    {
+      file_path: z7.string().describe("Absolute path to the file on disk")
+    },
+    async (params) => {
+      try {
+        const result = await client.postMultipart("/files", params.file_path);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "upload-file");
+        }
+        return transformNetworkError(error, "upload-file");
+      }
+    }
+  );
+  log9("Registered tool: upload-file");
+  return 1;
+}
+
+// packages/mcp/src/tools/custom/location-tools.ts
+import { z as z8 } from "zod";
+var log10 = createLogger("bukku-mcp");
+function registerLocationTools(server, client) {
+  server.tool(
+    "get-location",
+    "Get a location for multi-branch accounting by ID",
+    {
+      id: z8.number().describe("The location ID")
+    },
+    async (params) => {
+      try {
+        const result = await client.get(`/location/${params.id}`);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "get-location");
+        }
+        return transformNetworkError(error, "get-location");
+      }
+    }
+  );
+  log10("Registered tool: get-location");
+  server.tool(
+    "update-location",
+    "Update an existing location for multi-branch accounting",
+    {
+      id: z8.number().describe("The location ID"),
+      data: z8.record(z8.string(), z8.unknown()).describe("Updated data")
+    },
+    async (params) => {
+      try {
+        const result = await client.put(`/location/${params.id}`, params.data);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "update-location");
+        }
+        return transformNetworkError(error, "update-location");
+      }
+    }
+  );
+  log10("Registered tool: update-location");
+  server.tool(
+    "delete-location",
+    "Delete a location for multi-branch accounting. API may restrict deletion if location is referenced by transactions. Archive instead if deletion fails.",
+    {
+      id: z8.number().describe("The location ID")
+    },
+    async (params) => {
+      try {
+        await client.delete(`/location/${params.id}`);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Successfully deleted location with ID ${params.id}`
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "delete-location");
+        }
+        return transformNetworkError(error, "delete-location");
+      }
+    }
+  );
+  log10("Registered tool: delete-location");
+  return 3;
+}
+
+// packages/mcp/src/tools/custom/control-panel-archive.ts
+import { z as z9 } from "zod";
+var log11 = createLogger("bukku-mcp");
+function registerControlPanelArchiveTools(server, client) {
+  server.tool(
+    "archive-location",
+    "Archive a location (hide from active lists). Use this for locations referenced by transactions instead of deleting them.",
+    {
+      id: z9.number().describe("The location ID")
+    },
+    async (params) => {
+      try {
+        const result = await client.patch(`/location/${params.id}`, {
+          is_archived: true
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "archive-location");
+        }
+        return transformNetworkError(error, "archive-location");
+      }
+    }
+  );
+  log11("Registered tool: archive-location");
+  server.tool(
+    "unarchive-location",
+    "Unarchive a location (restore to active lists).",
+    {
+      id: z9.number().describe("The location ID")
+    },
+    async (params) => {
+      try {
+        const result = await client.patch(`/location/${params.id}`, {
+          is_archived: false
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        if (error instanceof Response) {
+          const body = await error.json().catch(() => null);
+          return transformHttpError(error.status, body, "unarchive-location");
+        }
+        return transformNetworkError(error, "unarchive-location");
+      }
+    }
+  );
+  log11("Registered tool: unarchive-location");
+  return 2;
+}
+
+// packages/mcp/src/tools/registry.ts
+function registerAllTools(server, client) {
+  let totalTools = 0;
+  totalTools += registerCrudTools(server, client, salesQuoteConfig);
+  totalTools += registerCrudTools(server, client, salesOrderConfig);
+  totalTools += registerCrudTools(server, client, deliveryOrderConfig);
+  totalTools += registerCrudTools(server, client, salesInvoiceConfig);
+  totalTools += registerCrudTools(server, client, salesCreditNoteConfig);
+  totalTools += registerCrudTools(server, client, salesPaymentConfig);
+  totalTools += registerCrudTools(server, client, salesRefundConfig);
+  totalTools += registerCrudTools(server, client, purchaseOrderConfig);
+  totalTools += registerCrudTools(server, client, goodsReceivedNoteConfig);
+  totalTools += registerCrudTools(server, client, purchaseBillConfig);
+  totalTools += registerCrudTools(server, client, purchaseCreditNoteConfig);
+  totalTools += registerCrudTools(server, client, purchasePaymentConfig);
+  totalTools += registerCrudTools(server, client, purchaseRefundConfig);
+  totalTools += registerCrudTools(server, client, bankMoneyInConfig);
+  totalTools += registerCrudTools(server, client, bankMoneyOutConfig);
+  totalTools += registerCrudTools(server, client, bankTransferConfig);
+  totalTools += registerCrudTools(server, client, contactConfig);
+  totalTools += registerCrudTools(server, client, contactGroupConfig);
+  totalTools += registerContactArchiveTools(server, client);
+  totalTools += registerCrudTools(server, client, productConfig);
+  totalTools += registerCrudTools(server, client, productBundleConfig);
+  totalTools += registerCrudTools(server, client, productGroupConfig);
+  totalTools += registerProductArchiveTools(server, client);
+  const referenceCache = new ReferenceDataCache();
+  totalTools += registerReferenceDataTools(server, client, referenceCache);
+  totalTools += registerCrudTools(server, client, journalEntryConfig);
+  totalTools += registerCrudTools(server, client, accountConfig);
+  totalTools += registerJournalEntryTools(server, client);
+  totalTools += registerAccountCustomTools(server, client);
+  totalTools += registerCrudTools(server, client, fileConfig);
+  totalTools += registerFileUploadTool(server, client);
+  totalTools += registerCrudTools(server, client, locationConfig);
+  totalTools += registerLocationTools(server, client);
+  totalTools += registerCrudTools(server, client, tagConfig);
+  totalTools += registerCrudTools(server, client, tagGroupConfig);
+  totalTools += registerControlPanelArchiveTools(server, client);
+  return totalTools;
+}
+
+// packages/mcp/src/index.ts
+var log12 = createLogger("bukku-mcp");
+var packageJsonPath = new URL("../package.json", import.meta.url);
+var pkg = JSON.parse(readFileSync(fileURLToPath(packageJsonPath), "utf-8"));
+async function main() {
+  const env = validateEnv();
+  const client = new BukkuClient({
+    apiToken: env.BUKKU_API_TOKEN,
+    companySubdomain: env.BUKKU_COMPANY_SUBDOMAIN
+  });
+  await client.validateToken();
+  const server = new McpServer({
+    name: "bukku",
+    version: pkg.version
+  });
+  const toolCount = registerAllTools(server, client);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  log12(`Bukku MCP server started (${toolCount} tools registered)`);
+}
+main().catch((error) => {
+  log12("Fatal error during startup:", error);
+  process.exit(1);
 });