@mindstone-engineering/mcp-server-quickbooks 0.1.0

package/dist/auth.d.ts

@@ -0,0 +1,31 @@
+/**
+ * QuickBooks Online authentication module.
+ *
+ * OAuth2 refresh token grant with token rotation.
+ * Credentials managed via env vars or configured at runtime.
+ * Supports sandbox vs production environment switching.
+ *
+ * Environment variables:
+ * - QUICKBOOKS_CLIENT_ID: Intuit Developer app Client ID
+ * - QUICKBOOKS_CLIENT_SECRET: Intuit Developer app Client Secret
+ * - QUICKBOOKS_REFRESH_TOKEN: OAuth2 refresh token
+ * - QUICKBOOKS_REALM_ID: QuickBooks company ID (Realm ID)
+ * - QUICKBOOKS_ENVIRONMENT: "sandbox" or "production" (default: "production")
+ */
+export declare function getClientId(): string;
+export declare function setClientId(id: string): void;
+export declare function getClientSecret(): string;
+export declare function setClientSecret(s: string): void;
+export declare function getRefreshToken(): string;
+export declare function setRefreshToken(t: string): void;
+export declare function getRealmId(): string;
+export declare function setRealmId(id: string): void;
+export declare function getEnvironment(): string;
+export declare function setEnvironment(env: string): void;
+export declare function clearTokenCache(): void;
+export declare function isConfigured(): boolean;
+export declare function getApiHost(): string;
+export declare function getBaseUrl(): string;
+export declare function validateEnvironment(env: string): boolean;
+export declare function getAccessToken(): Promise<string>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.js

@@ -0,0 +1,141 @@
+/**
+ * QuickBooks Online authentication module.
+ *
+ * OAuth2 refresh token grant with token rotation.
+ * Credentials managed via env vars or configured at runtime.
+ * Supports sandbox vs production environment switching.
+ *
+ * Environment variables:
+ * - QUICKBOOKS_CLIENT_ID: Intuit Developer app Client ID
+ * - QUICKBOOKS_CLIENT_SECRET: Intuit Developer app Client Secret
+ * - QUICKBOOKS_REFRESH_TOKEN: OAuth2 refresh token
+ * - QUICKBOOKS_REALM_ID: QuickBooks company ID (Realm ID)
+ * - QUICKBOOKS_ENVIRONMENT: "sandbox" or "production" (default: "production")
+ */
+import { QuickBooksError, TOKEN_URL, USER_AGENT, REQUEST_TIMEOUT_MS } from './types.js';
+import { bridgeRequest } from './bridge.js';
+// ── Runtime credentials ──
+let clientId = process.env.QUICKBOOKS_CLIENT_ID ?? '';
+let clientSecret = process.env.QUICKBOOKS_CLIENT_SECRET ?? '';
+let refreshToken = process.env.QUICKBOOKS_REFRESH_TOKEN ?? '';
+let realmId = process.env.QUICKBOOKS_REALM_ID ?? '';
+let environment = (() => {
+    const envVal = process.env.QUICKBOOKS_ENVIRONMENT ?? 'production';
+    if (envVal !== 'sandbox' && envVal !== 'production') {
+        throw new QuickBooksError(`Invalid QUICKBOOKS_ENVIRONMENT: "${envVal}". Must be "sandbox" or "production".`, 'INVALID_CONFIG', 'Set QUICKBOOKS_ENVIRONMENT to either "sandbox" or "production".');
+    }
+    return envVal;
+})();
+// ── Token cache ──
+let cachedAccessToken = null;
+let tokenExpiresAt = 0;
+// ── Getters / setters ──
+export function getClientId() {
+    return clientId;
+}
+export function setClientId(id) {
+    clientId = id;
+}
+export function getClientSecret() {
+    return clientSecret;
+}
+export function setClientSecret(s) {
+    clientSecret = s;
+}
+export function getRefreshToken() {
+    return refreshToken;
+}
+export function setRefreshToken(t) {
+    refreshToken = t;
+}
+export function getRealmId() {
+    return realmId;
+}
+export function setRealmId(id) {
+    realmId = id;
+}
+export function getEnvironment() {
+    return environment;
+}
+export function setEnvironment(env) {
+    environment = env;
+}
+export function clearTokenCache() {
+    cachedAccessToken = null;
+    tokenExpiresAt = 0;
+}
+export function isConfigured() {
+    return !!(clientId && clientSecret && refreshToken && realmId);
+}
+// ── Environment / URL helpers ──
+export function getApiHost() {
+    return environment === 'sandbox'
+        ? 'sandbox-quickbooks.api.intuit.com'
+        : 'quickbooks.api.intuit.com';
+}
+export function getBaseUrl() {
+    return `https://${getApiHost()}/v3/company/${realmId}`;
+}
+export function validateEnvironment(env) {
+    return env === 'sandbox' || env === 'production';
+}
+// ── Token exchange ──
+export async function getAccessToken() {
+    if (!clientId || !clientSecret || !refreshToken) {
+        throw new QuickBooksError('QuickBooks not configured. Call configure_quickbooks first.', 'NOT_CONFIGURED', 'Configure QuickBooks with your Intuit Developer app credentials first.');
+    }
+    if (cachedAccessToken && Date.now() < tokenExpiresAt) {
+        return cachedAccessToken;
+    }
+    const authHeader = 'Basic ' + Buffer.from(`${clientId}:${clientSecret}`).toString('base64');
+    const body = new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+    });
+    let response;
+    try {
+        response = await fetch(TOKEN_URL, {
+            method: 'POST',
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            headers: {
+                Authorization: authHeader,
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Accept: 'application/json',
+                'User-Agent': USER_AGENT,
+            },
+            body: body.toString(),
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'TimeoutError') {
+            throw new QuickBooksError('OAuth token request timed out', 'TIMEOUT', 'The request took too long. Check your network connectivity.');
+        }
+        throw error;
+    }
+    if (!response.ok) {
+        let errorText;
+        try {
+            const errorBody = await response.json();
+            errorText = errorBody?.error_description || errorBody?.error || JSON.stringify(errorBody);
+        }
+        catch {
+            errorText = await response.text().catch(() => 'Unknown error');
+        }
+        throw new QuickBooksError(`OAuth token refresh failed (${response.status}): ${errorText}`, 'AUTH_FAILED', 'Re-configure with configure_quickbooks. Check Client ID, Secret, and Refresh Token. Tokens expire after 100 days of inactivity.');
+    }
+    const tokenData = await response.json();
+    cachedAccessToken = tokenData.access_token;
+    // Expire 60 seconds early to avoid edge cases
+    tokenExpiresAt = Date.now() + (tokenData.expires_in - 60) * 1000;
+    // Handle refresh token rotation — Intuit may return a new refresh token
+    if (tokenData.refresh_token && tokenData.refresh_token !== refreshToken) {
+        refreshToken = tokenData.refresh_token;
+        bridgeRequest('/bundled/quickbooks/update-refresh-token', {
+            refreshToken: tokenData.refresh_token,
+        }).catch((err) => {
+            console.error('Failed to persist rotated refresh token:', err instanceof Error ? err.message : String(err));
+        });
+    }
+    return cachedAccessToken;
+}
+//# sourceMappingURL=auth.js.map

package/dist/bridge.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Path to bridge state file, supporting both current and legacy env vars.
+ */
+export declare const BRIDGE_STATE_PATH: string;
+/**
+ * Send a request to the host app bridge.
+ *
+ * The bridge is an HTTP server running inside the host app (e.g. Rebel)
+ * that handles credential management and other cross-process operations.
+ */
+export declare const bridgeRequest: (urlPath: string, body: Record<string, unknown>) => Promise<{
+    success: boolean;
+    warning?: string;
+    error?: string;
+}>;
+//# sourceMappingURL=bridge.d.ts.map

package/dist/bridge.js

@@ -0,0 +1,43 @@
+import * as fs from 'fs';
+import { REQUEST_TIMEOUT_MS } from './types.js';
+/**
+ * Path to bridge state file, supporting both current and legacy env vars.
+ */
+export const BRIDGE_STATE_PATH = process.env.MCP_HOST_BRIDGE_STATE || process.env.MINDSTONE_REBEL_BRIDGE_STATE || '';
+const loadBridgeState = () => {
+    if (!BRIDGE_STATE_PATH)
+        return null;
+    try {
+        const raw = fs.readFileSync(BRIDGE_STATE_PATH, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Send a request to the host app bridge.
+ *
+ * The bridge is an HTTP server running inside the host app (e.g. Rebel)
+ * that handles credential management and other cross-process operations.
+ */
+export const bridgeRequest = async (urlPath, body) => {
+    const bridge = loadBridgeState();
+    if (!bridge) {
+        return { success: false, error: 'Bridge not available' };
+    }
+    const response = await fetch(`http://127.0.0.1:${bridge.port}${urlPath}`, {
+        method: 'POST',
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${bridge.token}`,
+        },
+        body: JSON.stringify(body),
+    });
+    if (response.status === 401 || response.status === 403) {
+        return { success: false, error: `Bridge returned ${response.status}: unauthorized. Check host app authentication.` };
+    }
+    return response.json();
+};
+//# sourceMappingURL=bridge.js.map

package/dist/client.d.ts

@@ -0,0 +1,18 @@
+/**
+ * QuickBooks Online API HTTP client.
+ *
+ * Centralises Bearer auth injection, error handling,
+ * rate-limit retry with exponential backoff, and timeout handling.
+ *
+ * Auth: OAuth2 Bearer token via getAccessToken()
+ * Base URL: https://{host}/v3/company/{realmId}
+ */
+/**
+ * Make an authenticated JSON request to the QuickBooks Online API.
+ */
+export declare function qboFetch<T>(entityPath: string, options?: RequestInit, retryCount?: number): Promise<T>;
+/**
+ * Run a QuickBooks query using the Query Language.
+ */
+export declare function qboQuery<T>(entity: string, query: string, limit?: number, offset?: number): Promise<T[]>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.js

@@ -0,0 +1,91 @@
+/**
+ * QuickBooks Online API HTTP client.
+ *
+ * Centralises Bearer auth injection, error handling,
+ * rate-limit retry with exponential backoff, and timeout handling.
+ *
+ * Auth: OAuth2 Bearer token via getAccessToken()
+ * Base URL: https://{host}/v3/company/{realmId}
+ */
+import { QuickBooksError, USER_AGENT, REQUEST_TIMEOUT_MS } from './types.js';
+import { getAccessToken, getBaseUrl, isConfigured, clearTokenCache } from './auth.js';
+/**
+ * Make an authenticated JSON request to the QuickBooks Online API.
+ */
+export async function qboFetch(entityPath, options = {}, retryCount = 0) {
+    if (!isConfigured()) {
+        throw new QuickBooksError('QuickBooks not configured. Call configure_quickbooks first.', 'NOT_CONFIGURED', 'Configure QuickBooks with your Intuit Developer app credentials first.');
+    }
+    const accessToken = await getAccessToken();
+    const url = `${getBaseUrl()}${entityPath}`;
+    const headers = {
+        Authorization: `Bearer ${accessToken}`,
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+        'User-Agent': USER_AGENT,
+        ...options.headers,
+    };
+    console.error(`[QuickBooks API] ${options.method || 'GET'} ${url}`);
+    let response;
+    try {
+        response = await fetch(url, {
+            ...options,
+            signal: options.signal ?? AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            headers,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'TimeoutError') {
+            throw new QuickBooksError('Request to QuickBooks API timed out', 'TIMEOUT', 'The request took too long. Try again or check if the QuickBooks API is available.');
+        }
+        throw error;
+    }
+    if (!response.ok) {
+        // Handle 429 with exponential backoff (max 3 retries)
+        if (response.status === 429 && retryCount < 3) {
+            const retryAfter = response.headers.get('Retry-After');
+            const waitMs = retryAfter
+                ? parseInt(retryAfter, 10) * 1000
+                : Math.min(1000 * Math.pow(2, retryCount), 8000);
+            await new Promise((resolve) => setTimeout(resolve, waitMs));
+            return qboFetch(entityPath, options, retryCount + 1);
+        }
+        let errorText;
+        try {
+            const errorBody = await response.json();
+            const firstError = errorBody?.Fault?.Error?.[0];
+            errorText = firstError?.Detail || firstError?.Message || JSON.stringify(errorBody);
+        }
+        catch {
+            errorText = await response.text().catch(() => 'Unknown error');
+        }
+        if (response.status === 401) {
+            clearTokenCache();
+            throw new QuickBooksError(`Authentication failed (${response.status}): ${errorText}`, 'AUTH_FAILED', 'Re-configure with configure_quickbooks. Check your credentials.');
+        }
+        if (response.status === 403) {
+            throw new QuickBooksError(`Insufficient permissions (${response.status}): ${errorText}`, 'FORBIDDEN', 'Check your QuickBooks app permissions.');
+        }
+        if (response.status === 404) {
+            throw new QuickBooksError(`Resource not found (${response.status}): ${errorText}`, 'NOT_FOUND', 'Verify the entity type and ID are correct.');
+        }
+        if (response.status === 429) {
+            throw new QuickBooksError('Rate limited. Maximum retries exhausted.', 'RATE_LIMITED', 'Please wait before retrying.');
+        }
+        if (response.status >= 500) {
+            throw new QuickBooksError(`QuickBooks server error (${response.status}): ${errorText}`, 'SERVER_ERROR', 'QuickBooks server error. Try again later.');
+        }
+        throw new QuickBooksError(`QuickBooks API error (${response.status}): ${errorText}`, `HTTP_${response.status}`, 'Check the request parameters and try again.');
+    }
+    return await response.json();
+}
+/**
+ * Run a QuickBooks query using the Query Language.
+ */
+export async function qboQuery(entity, query, limit = 100, offset = 1) {
+    const fullQuery = `${query} MAXRESULTS ${limit} STARTPOSITION ${offset}`;
+    const encoded = encodeURIComponent(fullQuery);
+    const result = await qboFetch(`/query?query=${encoded}`);
+    return result.QueryResponse[entity] || [];
+}
+//# sourceMappingURL=client.js.map

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+/**
+ * QuickBooks Online MCP Server
+ *
+ * Provides QuickBooks Online accounting integration via Model Context Protocol.
+ * Covers invoices, bills, customers, vendors, employees, estimates, purchases,
+ * accounts, items, journal entries, and bill payments.
+ *
+ * Uses the QuickBooks Online REST API v3 directly via fetch().
+ * OAuth2 token refresh with rotation is handled internally.
+ *
+ * Environment variables:
+ * - QUICKBOOKS_CLIENT_ID: Intuit Developer app Client ID
+ * - QUICKBOOKS_CLIENT_SECRET: Intuit Developer app Client Secret
+ * - QUICKBOOKS_REFRESH_TOKEN: OAuth2 refresh token
+ * - QUICKBOOKS_REALM_ID: QuickBooks company ID (Realm ID)
+ * - QUICKBOOKS_ENVIRONMENT: "sandbox" or "production" (default: "production")
+ * - MCP_HOST_BRIDGE_STATE: Path to bridge state file for app communication
+ * - MINDSTONE_REBEL_BRIDGE_STATE: Legacy bridge state path
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+/**
+ * QuickBooks Online MCP Server
+ *
+ * Provides QuickBooks Online accounting integration via Model Context Protocol.
+ * Covers invoices, bills, customers, vendors, employees, estimates, purchases,
+ * accounts, items, journal entries, and bill payments.
+ *
+ * Uses the QuickBooks Online REST API v3 directly via fetch().
+ * OAuth2 token refresh with rotation is handled internally.
+ *
+ * Environment variables:
+ * - QUICKBOOKS_CLIENT_ID: Intuit Developer app Client ID
+ * - QUICKBOOKS_CLIENT_SECRET: Intuit Developer app Client Secret
+ * - QUICKBOOKS_REFRESH_TOKEN: OAuth2 refresh token
+ * - QUICKBOOKS_REALM_ID: QuickBooks company ID (Realm ID)
+ * - QUICKBOOKS_ENVIRONMENT: "sandbox" or "production" (default: "production")
+ * - MCP_HOST_BRIDGE_STATE: Path to bridge state file for app communication
+ * - MINDSTONE_REBEL_BRIDGE_STATE: Legacy bridge state path
+ */
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createServer } from './server.js';
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('QuickBooks Online MCP server running on stdio');
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createServer(): McpServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -0,0 +1,18 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerConfigureTools, registerQueryTools, registerInvoiceTools, registerCustomerTools, registerBillTools, registerVendorTools, registerAccountTools, registerEmployeeTools, } from './tools/index.js';
+export function createServer() {
+    const server = new McpServer({
+        name: 'quickbooks-mcp-server',
+        version: '0.1.0',
+    });
+    registerConfigureTools(server);
+    registerQueryTools(server);
+    registerInvoiceTools(server);
+    registerCustomerTools(server);
+    registerBillTools(server);
+    registerVendorTools(server);
+    registerAccountTools(server);
+    registerEmployeeTools(server);
+    return server;
+}
+//# sourceMappingURL=server.js.map

package/dist/tools/accounts.d.ts

@@ -0,0 +1,6 @@
+/**
+ * QuickBooks account (chart of accounts) tools.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAccountTools(server: McpServer): void;
+//# sourceMappingURL=accounts.d.ts.map

package/dist/tools/accounts.js

@@ -0,0 +1,36 @@
+/**
+ * QuickBooks account (chart of accounts) tools.
+ */
+import { z } from 'zod';
+import { withErrorHandling } from '../utils.js';
+import { qboQuery } from '../client.js';
+export function registerAccountTools(server) {
+    server.registerTool('list_quickbooks_accounts', {
+        description: `List chart of accounts from QuickBooks Online.
+
+Returns: Id, Name, AccountType, AccountSubType, CurrentBalance, Active.
+
+Example: {}
+Example: { "accountType": "Expense" }
+
+Account types: Bank, Accounts Receivable, Other Current Asset, Fixed Asset, Other Asset, Accounts Payable, Credit Card, Other Current Liability, Long Term Liability, Equity, Income, Cost of Goods Sold, Expense, Other Income, Other Expense.`,
+        inputSchema: z.object({
+            accountType: z.string().optional().describe('Filter by account type (e.g., "Expense", "Income", "Bank")'),
+            active: z.boolean().optional().describe('Filter by active status'),
+            limit: z.number().optional().describe('Max results (default: 100)'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const limit = Math.min(args.limit ?? 100, 1000);
+        const conditions = [];
+        if (args.accountType)
+            conditions.push(`AccountType = '${args.accountType}'`);
+        if (args.active !== undefined)
+            conditions.push(`Active = ${args.active}`);
+        const where = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+        const query = `SELECT * FROM Account${where} ORDERBY Name`;
+        const accounts = await qboQuery('Account', query, limit);
+        return JSON.stringify({ ok: true, accounts, count: accounts.length });
+    }));
+}
+//# sourceMappingURL=accounts.js.map

package/dist/tools/bills.d.ts

@@ -0,0 +1,6 @@
+/**
+ * QuickBooks bill tools.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerBillTools(server: McpServer): void;
+//# sourceMappingURL=bills.d.ts.map

package/dist/tools/bills.js

@@ -0,0 +1,67 @@
+/**
+ * QuickBooks bill tools.
+ */
+import { z } from 'zod';
+import { withErrorHandling } from '../utils.js';
+import { qboFetch, qboQuery } from '../client.js';
+export function registerBillTools(server) {
+    server.registerTool('list_quickbooks_bills', {
+        description: `List bills (accounts payable) from QuickBooks Online.
+
+Returns: Id, DocNumber, TxnDate, DueDate, Balance, TotalAmt, VendorRef.
+
+Example: {}
+Example: { "vendorId": "123" }`,
+        inputSchema: z.object({
+            vendorId: z.string().optional().describe('Filter by vendor ID'),
+            limit: z.number().optional().describe('Max results (default: 50)'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const limit = Math.min(args.limit ?? 50, 1000);
+        const where = args.vendorId ? ` WHERE VendorRef = '${args.vendorId}'` : '';
+        const query = `SELECT * FROM Bill${where} ORDERBY TxnDate DESC`;
+        const bills = await qboQuery('Bill', query, limit);
+        return JSON.stringify({ ok: true, bills, count: bills.length });
+    }));
+    server.registerTool('create_quickbooks_bill', {
+        description: `Create a new bill (accounts payable) in QuickBooks Online.
+
+Example: { "vendorId": "123", "lines": [{ "description": "Office supplies", "amount": 250, "accountId": "456" }] }
+
+WORKFLOW:
+1. Use list_quickbooks_vendors to find the vendor ID
+2. Use list_quickbooks_accounts to find expense account IDs
+3. Create with line items`,
+        inputSchema: z.object({
+            vendorId: z.string().describe('Vendor ID (required)'),
+            lines: z.array(z.object({
+                description: z.string().describe('Line description'),
+                amount: z.number().describe('Line amount'),
+                accountId: z.string().optional().describe('Expense account ID'),
+            })).describe('Bill line items'),
+            dueDate: z.string().optional().describe('Due date (YYYY-MM-DD)'),
+            memo: z.string().optional().describe('Memo / notes'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const billBody = {
+            VendorRef: { value: args.vendorId },
+            Line: args.lines.map((line) => ({
+                Amount: line.amount,
+                DetailType: 'AccountBasedExpenseLineDetail',
+                Description: line.description,
+                AccountBasedExpenseLineDetail: {
+                    ...(line.accountId ? { AccountRef: { value: line.accountId } } : {}),
+                },
+            })),
+        };
+        if (args.dueDate)
+            billBody.DueDate = args.dueDate;
+        if (args.memo)
+            billBody.PrivateNote = args.memo;
+        const result = await qboFetch('/bill?minorversion=65', { method: 'POST', body: JSON.stringify(billBody) });
+        return JSON.stringify({ ok: true, message: 'Bill created.', bill: result.Bill });
+    }));
+}
+//# sourceMappingURL=bills.js.map

package/dist/tools/configure.d.ts

@@ -0,0 +1,9 @@
+/**
+ * QuickBooks credential configuration tool.
+ *
+ * Validates credentials via token exchange, persists via bridge,
+ * and updates runtime credentials.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerConfigureTools(server: McpServer): void;
+//# sourceMappingURL=configure.d.ts.map

package/dist/tools/configure.js

@@ -0,0 +1,110 @@
+/**
+ * QuickBooks credential configuration tool.
+ *
+ * Validates credentials via token exchange, persists via bridge,
+ * and updates runtime credentials.
+ */
+import { z } from 'zod';
+import { TOKEN_URL, USER_AGENT, REQUEST_TIMEOUT_MS } from '../types.js';
+import { withErrorHandling } from '../utils.js';
+import { setClientId, setClientSecret, setRefreshToken, setRealmId, setEnvironment, clearTokenCache, validateEnvironment, } from '../auth.js';
+import { bridgeRequest } from '../bridge.js';
+export function registerConfigureTools(server) {
+    server.registerTool('configure_quickbooks', {
+        description: `Configure QuickBooks Online credentials. Call this when the user provides their Intuit Developer app credentials.
+
+WORKFLOW:
+1. Go to https://developer.intuit.com/ and create an app (or use existing)
+2. Get the Client ID and Client Secret from the app's Keys & credentials page
+3. Add http://localhost:8000/callback as a Redirect URI
+4. Use the OAuth Playground or your app's auth flow to obtain a Refresh Token
+5. Find your Company ID (Realm ID) in the URL when logged into QuickBooks Online
+
+COMMON MISTAKES:
+- Refresh tokens expire after 100 days of inactivity — re-authenticate if you get auth errors
+- The Realm ID is NOT the same as the Client ID — it's your company identifier
+- Sandbox and Production use different credentials`,
+        inputSchema: z.object({
+            clientId: z.string().describe('Intuit Developer app Client ID'),
+            clientSecret: z.string().describe('Intuit Developer app Client Secret'),
+            refreshToken: z.string().describe('OAuth2 refresh token from the authorization flow'),
+            realmId: z.string().describe('QuickBooks company ID (Realm ID)'),
+            environment: z.enum(['sandbox', 'production']).optional().default('production')
+                .describe('"sandbox" or "production" (default: production)'),
+        }),
+        annotations: { destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const cid = args.clientId.trim();
+        const csecret = args.clientSecret.trim();
+        const rtoken = args.refreshToken.trim();
+        const rid = args.realmId.trim();
+        const env = args.environment?.trim().toLowerCase() ?? 'production';
+        if (!cid || !csecret || !rtoken || !rid) {
+            return JSON.stringify({ ok: false, error: 'clientId, clientSecret, refreshToken, and realmId are all required.' });
+        }
+        if (!validateEnvironment(env)) {
+            return JSON.stringify({ ok: false, error: 'environment must be "sandbox" or "production".' });
+        }
+        // Validate credentials by attempting a token refresh
+        const authHeader = 'Basic ' + Buffer.from(`${cid}:${csecret}`).toString('base64');
+        const body = new URLSearchParams({
+            grant_type: 'refresh_token',
+            refresh_token: rtoken,
+        });
+        let tokenResponse;
+        try {
+            tokenResponse = await fetch(TOKEN_URL, {
+                method: 'POST',
+                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+                headers: {
+                    Authorization: authHeader,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json',
+                    'User-Agent': USER_AGENT,
+                },
+                body: body.toString(),
+            });
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'TimeoutError') {
+                return JSON.stringify({
+                    ok: false,
+                    error: 'Token exchange request timed out.',
+                    resolution: 'Verify your network connectivity.',
+                });
+            }
+            return JSON.stringify({
+                ok: false,
+                error: `Could not reach Intuit OAuth: ${error instanceof Error ? error.message : String(error)}`,
+                resolution: 'Verify your network connectivity.',
+            });
+        }
+        if (!tokenResponse.ok) {
+            const errorBody = await tokenResponse.json().catch(() => ({}));
+            return JSON.stringify({
+                ok: false,
+                error: `Invalid credentials: ${errorBody?.error_description || `HTTP ${tokenResponse.status}`}`,
+                resolution: 'Check your Client ID, Client Secret, and Refresh Token. Refresh tokens expire after 100 days of inactivity.',
+            });
+        }
+        // Persist via bridge
+        const result = await bridgeRequest('/bundled/quickbooks/configure', {
+            clientId: cid, clientSecret: csecret, refreshToken: rtoken, realmId: rid, environment: env,
+        });
+        if (!result.success) {
+            return JSON.stringify({ ok: false, error: result.error || 'Failed to configure QuickBooks via bridge.' });
+        }
+        // Update runtime credentials
+        setClientId(cid);
+        setClientSecret(csecret);
+        setRefreshToken(rtoken);
+        setRealmId(rid);
+        setEnvironment(env);
+        clearTokenCache();
+        const message = result.warning
+            ? `QuickBooks Online configured successfully. Note: ${result.warning}`
+            : 'QuickBooks Online configured successfully! Try list_quickbooks_invoices or list_quickbooks_customers.';
+        return JSON.stringify({ ok: true, message });
+    }));
+}
+//# sourceMappingURL=configure.js.map

package/dist/tools/customers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * QuickBooks customer tools.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerCustomerTools(server: McpServer): void;
+//# sourceMappingURL=customers.d.ts.map

package/dist/tools/customers.js

@@ -0,0 +1,59 @@
+/**
+ * QuickBooks customer tools.
+ */
+import { z } from 'zod';
+import { withErrorHandling } from '../utils.js';
+import { qboFetch, qboQuery } from '../client.js';
+export function registerCustomerTools(server) {
+    server.registerTool('list_quickbooks_customers', {
+        description: `List customers from QuickBooks Online.
+
+Returns: Id, DisplayName, PrimaryEmailAddr, PrimaryPhone, Balance, Active.
+
+Example: {}
+Example: { "active": true }
+Example: { "searchTerm": "Smith" }`,
+        inputSchema: z.object({
+            active: z.boolean().optional().describe('Filter by active status'),
+            searchTerm: z.string().optional().describe('Search by display name (partial match)'),
+            limit: z.number().optional().describe('Max results (default: 50)'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const limit = Math.min(args.limit ?? 50, 1000);
+        const conditions = [];
+        if (args.active !== undefined)
+            conditions.push(`Active = ${args.active}`);
+        if (args.searchTerm) {
+            conditions.push(`DisplayName LIKE '%${args.searchTerm.replace(/'/g, "\\'")}%'`);
+        }
+        const where = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+        const query = `SELECT * FROM Customer${where} ORDERBY DisplayName`;
+        const customers = await qboQuery('Customer', query, limit);
+        return JSON.stringify({ ok: true, customers, count: customers.length });
+    }));
+    server.registerTool('create_quickbooks_customer', {
+        description: `Create a new customer in QuickBooks Online.
+
+Example: { "displayName": "Acme Corp" }
+Example: { "displayName": "Jane Smith", "email": "jane@smith.com", "phone": "555-1234" }`,
+        inputSchema: z.object({
+            displayName: z.string().describe('Customer display name (required, must be unique)'),
+            email: z.string().optional().describe('Primary email address'),
+            phone: z.string().optional().describe('Primary phone number'),
+            companyName: z.string().optional().describe('Company name'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const customerBody = { DisplayName: args.displayName };
+        if (args.email)
+            customerBody.PrimaryEmailAddr = { Address: args.email };
+        if (args.phone)
+            customerBody.PrimaryPhone = { FreeFormNumber: args.phone };
+        if (args.companyName)
+            customerBody.CompanyName = args.companyName;
+        const result = await qboFetch('/customer?minorversion=65', { method: 'POST', body: JSON.stringify(customerBody) });
+        return JSON.stringify({ ok: true, message: 'Customer created.', customer: result.Customer });
+    }));
+}
+//# sourceMappingURL=customers.js.map

package/dist/tools/employees.d.ts

@@ -0,0 +1,6 @@
+/**
+ * QuickBooks employee tools.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerEmployeeTools(server: McpServer): void;
+//# sourceMappingURL=employees.d.ts.map

package/dist/tools/employees.js

@@ -0,0 +1,29 @@
+/**
+ * QuickBooks employee tools.
+ */
+import { z } from 'zod';
+import { withErrorHandling } from '../utils.js';
+import { qboQuery } from '../client.js';
+export function registerEmployeeTools(server) {
+    server.registerTool('list_quickbooks_employees', {
+        description: `List employees from QuickBooks Online.
+
+Returns: Id, DisplayName, PrimaryEmailAddr, PrimaryPhone, Active.
+
+Example: {}`,
+        inputSchema: z.object({
+            active: z.boolean().optional().describe('Filter by active status'),
+            limit: z.number().optional().describe('Max results (default: 50)'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const limit = Math.min(args.limit ?? 50, 1000);
+        let where = '';
+        if (args.active !== undefined)
+            where = ` WHERE Active = ${args.active}`;
+        const query = `SELECT * FROM Employee${where} ORDERBY DisplayName`;
+        const employees = await qboQuery('Employee', query, limit);
+        return JSON.stringify({ ok: true, employees, count: employees.length });
+    }));
+}
+//# sourceMappingURL=employees.js.map

package/dist/tools/index.d.ts

@@ -0,0 +1,9 @@
+export { registerConfigureTools } from './configure.js';
+export { registerQueryTools } from './query.js';
+export { registerInvoiceTools } from './invoices.js';
+export { registerCustomerTools } from './customers.js';
+export { registerBillTools } from './bills.js';
+export { registerVendorTools } from './vendors.js';
+export { registerAccountTools } from './accounts.js';
+export { registerEmployeeTools } from './employees.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -0,0 +1,9 @@
+export { registerConfigureTools } from './configure.js';
+export { registerQueryTools } from './query.js';
+export { registerInvoiceTools } from './invoices.js';
+export { registerCustomerTools } from './customers.js';
+export { registerBillTools } from './bills.js';
+export { registerVendorTools } from './vendors.js';
+export { registerAccountTools } from './accounts.js';
+export { registerEmployeeTools } from './employees.js';
+//# sourceMappingURL=index.js.map

package/dist/tools/invoices.d.ts

@@ -0,0 +1,6 @@
+/**
+ * QuickBooks invoice tools.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerInvoiceTools(server: McpServer): void;
+//# sourceMappingURL=invoices.d.ts.map

package/dist/tools/invoices.js

@@ -0,0 +1,93 @@
+/**
+ * QuickBooks invoice tools.
+ */
+import { z } from 'zod';
+import { withErrorHandling } from '../utils.js';
+import { qboFetch, qboQuery } from '../client.js';
+export function registerInvoiceTools(server) {
+    server.registerTool('list_quickbooks_invoices', {
+        description: `List invoices from QuickBooks Online.
+
+Returns: Id, DocNumber, TxnDate, DueDate, Balance, TotalAmt, CustomerRef, Line items.
+
+Example: {}
+Example: { "status": "unpaid" }
+Example: { "customerId": "123" }
+
+WORKFLOW:
+1. Call with no args to see recent invoices
+2. Filter by status (unpaid/paid/overdue) or customer
+3. Use get_quickbooks_entity for full invoice details`,
+        inputSchema: z.object({
+            status: z.enum(['unpaid', 'paid', 'overdue']).optional()
+                .describe('Filter: "unpaid", "paid", or "overdue"'),
+            customerId: z.string().optional().describe('Filter by customer ID'),
+            limit: z.number().optional().describe('Max results (default: 50)'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const limit = Math.min(args.limit ?? 50, 1000);
+        const conditions = [];
+        if (args.status === 'unpaid')
+            conditions.push("Balance > '0'");
+        else if (args.status === 'paid')
+            conditions.push("Balance = '0'");
+        else if (args.status === 'overdue') {
+            conditions.push(`Balance > '0' AND DueDate < '${new Date().toISOString().split('T')[0]}'`);
+        }
+        if (args.customerId)
+            conditions.push(`CustomerRef = '${args.customerId}'`);
+        const where = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+        const query = `SELECT * FROM Invoice${where} ORDERBY TxnDate DESC`;
+        const invoices = await qboQuery('Invoice', query, limit);
+        return JSON.stringify({ ok: true, invoices, count: invoices.length });
+    }));
+    server.registerTool('create_quickbooks_invoice', {
+        description: `Create a new invoice in QuickBooks Online.
+
+Example: { "customerId": "123", "lines": [{ "description": "Consulting services", "amount": 1500 }] }
+
+WORKFLOW:
+1. Use list_quickbooks_customers to find the customer ID
+2. Create with line items (description + amount required)
+3. Optionally set dueDate and memo
+
+COMMON MISTAKES:
+- customerId is required (use list_quickbooks_customers to find it)
+- Each line needs at least description and amount
+- Dates use YYYY-MM-DD format`,
+        inputSchema: z.object({
+            customerId: z.string().describe('Customer ID (required)'),
+            lines: z.array(z.object({
+                description: z.string().describe('Line description'),
+                amount: z.number().describe('Line amount'),
+                qty: z.number().optional().describe('Quantity (default: 1)'),
+                itemId: z.string().optional().describe('Item/service ID (optional)'),
+            })).describe('Invoice line items'),
+            dueDate: z.string().optional().describe('Due date (YYYY-MM-DD)'),
+            memo: z.string().optional().describe('Customer memo / notes'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const invoiceBody = {
+            CustomerRef: { value: args.customerId },
+            Line: args.lines.map((line) => ({
+                Amount: line.amount,
+                DetailType: 'SalesItemLineDetail',
+                Description: line.description,
+                SalesItemLineDetail: {
+                    Qty: line.qty || 1,
+                    UnitPrice: line.amount / (line.qty || 1),
+                    ...(line.itemId ? { ItemRef: { value: line.itemId } } : {}),
+                },
+            })),
+        };
+        if (args.dueDate)
+            invoiceBody.DueDate = args.dueDate;
+        if (args.memo)
+            invoiceBody.CustomerMemo = { value: args.memo };
+        const result = await qboFetch('/invoice?minorversion=65', { method: 'POST', body: JSON.stringify(invoiceBody) });
+        return JSON.stringify({ ok: true, message: 'Invoice created.', invoice: result.Invoice });
+    }));
+}
+//# sourceMappingURL=invoices.js.map

package/dist/tools/query.d.ts

@@ -0,0 +1,6 @@
+/**
+ * QuickBooks query and entity retrieval tools.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerQueryTools(server: McpServer): void;
+//# sourceMappingURL=query.d.ts.map

package/dist/tools/query.js

@@ -0,0 +1,59 @@
+/**
+ * QuickBooks query and entity retrieval tools.
+ */
+import { z } from 'zod';
+import { withErrorHandling } from '../utils.js';
+import { qboFetch, qboQuery } from '../client.js';
+export function registerQueryTools(server) {
+    server.registerTool('query_quickbooks', {
+        description: `Run a QuickBooks query using the QuickBooks Query Language.
+
+Returns matching entities. QuickBooks uses a SQL-like query language.
+
+Example: { "query": "SELECT * FROM Invoice WHERE Balance > '0' ORDERBY DueDate" }
+Example: { "query": "SELECT * FROM Customer WHERE Active = true" }
+
+WORKFLOW:
+1. Use this for flexible searches across any entity type
+2. Entity names are PascalCase: Invoice, Customer, Vendor, Bill, Employee, etc.
+3. String values use single quotes, dates use 'YYYY-MM-DD' format
+
+COMMON MISTAKES:
+- Entity names are case-sensitive PascalCase (Invoice, not invoice)
+- Use single quotes for string/date values, not double quotes
+- LIKE operator uses % wildcard: DisplayName LIKE '%Smith%'`,
+        inputSchema: z.object({
+            query: z.string().describe('QuickBooks Query Language statement'),
+            limit: z.number().optional().describe('Max results (default: 100, max: 1000)'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const query = args.query;
+        const limit = Math.min(args.limit ?? 100, 1000);
+        // Extract entity name from query for response parsing
+        const entityMatch = query.match(/FROM\s+(\w+)/i);
+        const entityName = entityMatch ? entityMatch[1] : 'Unknown';
+        const results = await qboQuery(entityName, query, limit);
+        return JSON.stringify({ ok: true, entity: entityName, data: results, count: results.length });
+    }));
+    server.registerTool('get_quickbooks_entity', {
+        description: `Get a single QuickBooks entity by type and ID.
+
+Example: { "entityType": "Invoice", "entityId": "123" }
+
+Supported entity types: Account, Bill, BillPayment, Customer, Employee, Estimate, Invoice, Item, JournalEntry, Purchase, Vendor`,
+        inputSchema: z.object({
+            entityType: z.enum([
+                'Account', 'Bill', 'BillPayment', 'Customer', 'Employee',
+                'Estimate', 'Invoice', 'Item', 'JournalEntry', 'Purchase', 'Vendor',
+            ]).describe('Entity type (PascalCase)'),
+            entityId: z.string().describe('Entity ID'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const { entityType, entityId } = args;
+        const result = await qboFetch(`/${entityType.toLowerCase()}/${encodeURIComponent(entityId)}?minorversion=65`);
+        return JSON.stringify({ ok: true, [entityType]: result[entityType] || result });
+    }));
+}
+//# sourceMappingURL=query.js.map

package/dist/tools/vendors.d.ts

@@ -0,0 +1,6 @@
+/**
+ * QuickBooks vendor tools.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerVendorTools(server: McpServer): void;
+//# sourceMappingURL=vendors.d.ts.map

package/dist/tools/vendors.js

@@ -0,0 +1,58 @@
+/**
+ * QuickBooks vendor tools.
+ */
+import { z } from 'zod';
+import { withErrorHandling } from '../utils.js';
+import { qboFetch, qboQuery } from '../client.js';
+export function registerVendorTools(server) {
+    server.registerTool('list_quickbooks_vendors', {
+        description: `List vendors from QuickBooks Online.
+
+Returns: Id, DisplayName, PrimaryEmailAddr, PrimaryPhone, Balance, Active.
+
+Example: {}
+Example: { "searchTerm": "Office" }`,
+        inputSchema: z.object({
+            active: z.boolean().optional().describe('Filter by active status'),
+            searchTerm: z.string().optional().describe('Search by display name (partial match)'),
+            limit: z.number().optional().describe('Max results (default: 50)'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const limit = Math.min(args.limit ?? 50, 1000);
+        const conditions = [];
+        if (args.active !== undefined)
+            conditions.push(`Active = ${args.active}`);
+        if (args.searchTerm) {
+            conditions.push(`DisplayName LIKE '%${args.searchTerm.replace(/'/g, "\\'")}%'`);
+        }
+        const where = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+        const query = `SELECT * FROM Vendor${where} ORDERBY DisplayName`;
+        const vendors = await qboQuery('Vendor', query, limit);
+        return JSON.stringify({ ok: true, vendors, count: vendors.length });
+    }));
+    server.registerTool('create_quickbooks_vendor', {
+        description: `Create a new vendor in QuickBooks Online.
+
+Example: { "displayName": "Office Depot" }
+Example: { "displayName": "AWS", "email": "billing@aws.amazon.com", "companyName": "Amazon Web Services" }`,
+        inputSchema: z.object({
+            displayName: z.string().describe('Vendor display name (required, must be unique)'),
+            email: z.string().optional().describe('Primary email address'),
+            phone: z.string().optional().describe('Primary phone number'),
+            companyName: z.string().optional().describe('Company name'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const vendorBody = { DisplayName: args.displayName };
+        if (args.email)
+            vendorBody.PrimaryEmailAddr = { Address: args.email };
+        if (args.phone)
+            vendorBody.PrimaryPhone = { FreeFormNumber: args.phone };
+        if (args.companyName)
+            vendorBody.CompanyName = args.companyName;
+        const result = await qboFetch('/vendor?minorversion=65', { method: 'POST', body: JSON.stringify(vendorBody) });
+        return JSON.stringify({ ok: true, message: 'Vendor created.', vendor: result.Vendor });
+    }));
+}
+//# sourceMappingURL=vendors.js.map

package/dist/types.d.ts

@@ -0,0 +1,13 @@
+export declare const REQUEST_TIMEOUT_MS = 30000;
+export declare const USER_AGENT = "MindstoneRebel/1.0 (QuickBooks-MCP)";
+export declare const TOKEN_URL = "https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer";
+export interface BridgeState {
+    port: number;
+    token: string;
+}
+export declare class QuickBooksError extends Error {
+    readonly code: string;
+    readonly resolution: string;
+    constructor(message: string, code: string, resolution: string);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,14 @@
+export const REQUEST_TIMEOUT_MS = 30_000;
+export const USER_AGENT = 'MindstoneRebel/1.0 (QuickBooks-MCP)';
+export const TOKEN_URL = 'https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer';
+export class QuickBooksError extends Error {
+    code;
+    resolution;
+    constructor(message, code, resolution) {
+        super(message);
+        this.code = code;
+        this.resolution = resolution;
+        this.name = 'QuickBooksError';
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/utils.d.ts

@@ -0,0 +1,14 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+type ToolHandler<T> = (args: T, extra: unknown) => Promise<CallToolResult>;
+/**
+ * Wraps a tool handler with standard error handling.
+ *
+ * - On success: returns the string result as a text content block.
+ * - On QuickBooksError: returns a structured JSON error with code and resolution.
+ * - On unknown error: returns a generic error message.
+ *
+ * Secrets are never exposed in error messages.
+ */
+export declare function withErrorHandling<T>(fn: (args: T, extra: unknown) => Promise<string>): ToolHandler<T>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -0,0 +1,42 @@
+import { QuickBooksError } from './types.js';
+/**
+ * Wraps a tool handler with standard error handling.
+ *
+ * - On success: returns the string result as a text content block.
+ * - On QuickBooksError: returns a structured JSON error with code and resolution.
+ * - On unknown error: returns a generic error message.
+ *
+ * Secrets are never exposed in error messages.
+ */
+export function withErrorHandling(fn) {
+    return async (args, extra) => {
+        try {
+            const result = await fn(args, extra);
+            return { content: [{ type: 'text', text: result }] };
+        }
+        catch (error) {
+            if (error instanceof QuickBooksError) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                ok: false,
+                                error: error.message,
+                                code: error.code,
+                                resolution: error.resolution,
+                            }),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ ok: false, error: errorMessage }) }],
+                isError: true,
+            };
+        }
+    };
+}
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@mindstone-engineering/mcp-server-quickbooks",
+  "version": "0.1.0",
+  "description": "QuickBooks Online MCP server for Model Context Protocol hosts — invoices, bills, customers, vendors, accounts",
+  "license": "FSL-1.1-MIT",
+  "type": "module",
+  "bin": {
+    "mcp-server-quickbooks": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nspr-io/mcp-servers.git",
+    "directory": "connectors/quickbooks"
+  },
+  "homepage": "https://github.com/nspr-io/mcp-servers/tree/main/connectors/quickbooks",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc && shx chmod +x dist/index.js",
+    "prepare": "npm run build",
+    "watch": "tsc --watch",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@mindstone-engineering/mcp-test-harness": "file:../../test-harness",
+    "@types/node": "^22",
+    "@vitest/coverage-v8": "^4.1.3",
+    "msw": "^2.13.2",
+    "shx": "^0.3.4",
+    "typescript": "^5.8.2",
+    "vitest": "^4.1.3"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}