@mindstone-engineering/mcp-server-freshdesk 0.1.0

package/dist/auth.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Freshdesk authentication and multi-account management module.
+ *
+ * Supports multiple Freshdesk accounts stored in a file-backed accounts.json.
+ * Hot-reloads accounts from disk on every getAccount() call to pick up
+ * external changes (e.g. from the host app bridge).
+ *
+ * Auth format: Basic base64(apiKey:X)
+ *
+ * File permissions:
+ * - accounts.json: 0o600 (read/write owner only)
+ * - config directory: 0o700 (rwx owner only)
+ */
+import type { AccountsConfig, AccountInfo, FreshdeskAccount } from './types.js';
+/**
+ * Returns the config directory path.
+ */
+export declare function getConfigPath(): string;
+/**
+ * Load accounts from accounts.json.
+ * Called on every getAccount() call to support hot-reload.
+ */
+export declare function loadAccounts(): void;
+/**
+ * Get the current in-memory accounts config (for listing, etc.).
+ */
+export declare function getAccountsConfig(): AccountsConfig;
+/**
+ * Get an account by domain, with hot-reload support.
+ * If no domain specified, returns the default or first account.
+ */
+export declare function getAccount(domain?: string): FreshdeskAccount | undefined;
+/**
+ * Save accounts.json with secure file permissions.
+ */
+export declare function saveAccounts(config: AccountsConfig): void;
+/**
+ * Remove an account by domain. Returns true if found and removed.
+ */
+export declare function removeAccount(domain: string): boolean;
+/**
+ * Add or update an account. Saves to disk with proper permissions.
+ */
+export declare function upsertAccount(info: AccountInfo): void;
+//# sourceMappingURL=auth.d.ts.map

package/dist/auth.js

@@ -0,0 +1,135 @@
+/**
+ * Freshdesk authentication and multi-account management module.
+ *
+ * Supports multiple Freshdesk accounts stored in a file-backed accounts.json.
+ * Hot-reloads accounts from disk on every getAccount() call to pick up
+ * external changes (e.g. from the host app bridge).
+ *
+ * Auth format: Basic base64(apiKey:X)
+ *
+ * File permissions:
+ * - accounts.json: 0o600 (read/write owner only)
+ * - config directory: 0o700 (rwx owner only)
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const CONFIG_PATH = process.env.FRESHDESK_CONFIG_PATH || path.join(os.homedir(), '.mcp', 'freshdesk');
+let accountsConfig = { accounts: [] };
+/**
+ * Returns the config directory path.
+ */
+export function getConfigPath() {
+    return CONFIG_PATH;
+}
+/**
+ * Load accounts from accounts.json.
+ * Called on every getAccount() call to support hot-reload.
+ */
+export function loadAccounts() {
+    const accountsPath = path.join(CONFIG_PATH, 'accounts.json');
+    try {
+        if (fs.existsSync(accountsPath)) {
+            const raw = fs.readFileSync(accountsPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (parsed && Array.isArray(parsed.accounts)) {
+                accountsConfig = {
+                    accounts: parsed.accounts,
+                    defaultDomain: typeof parsed.defaultDomain === 'string' ? parsed.defaultDomain : undefined,
+                };
+            }
+            else {
+                accountsConfig = { accounts: [] };
+            }
+        }
+    }
+    catch {
+        accountsConfig = { accounts: [] };
+    }
+}
+/**
+ * Get the current in-memory accounts config (for listing, etc.).
+ */
+export function getAccountsConfig() {
+    return accountsConfig;
+}
+/**
+ * Get an account by domain, with hot-reload support.
+ * If no domain specified, returns the default or first account.
+ */
+export function getAccount(domain) {
+    // Hot-reload: always reload accounts from disk
+    loadAccounts();
+    if (accountsConfig.accounts.length === 0)
+        return undefined;
+    let info;
+    if (domain) {
+        info = accountsConfig.accounts.find((a) => a.domain === domain);
+    }
+    else {
+        const defaultDom = accountsConfig.defaultDomain;
+        if (defaultDom) {
+            info = accountsConfig.accounts.find((a) => a.domain === defaultDom);
+        }
+        if (!info) {
+            info = accountsConfig.accounts[0];
+        }
+    }
+    if (!info)
+        return undefined;
+    return {
+        domain: info.domain,
+        apiKey: info.apiKey,
+        agentEmail: info.agentEmail,
+    };
+}
+/**
+ * Save accounts.json with secure file permissions.
+ */
+export function saveAccounts(config) {
+    // Ensure config directory exists with 0o700 permissions
+    if (!fs.existsSync(CONFIG_PATH)) {
+        fs.mkdirSync(CONFIG_PATH, { recursive: true, mode: 0o700 });
+    }
+    const accountsPath = path.join(CONFIG_PATH, 'accounts.json');
+    fs.writeFileSync(accountsPath, JSON.stringify(config, null, 2), { mode: 0o600 });
+    // Update in-memory state
+    accountsConfig = config;
+}
+/**
+ * Remove an account by domain. Returns true if found and removed.
+ */
+export function removeAccount(domain) {
+    loadAccounts();
+    const idx = accountsConfig.accounts.findIndex((a) => a.domain === domain);
+    if (idx < 0)
+        return false;
+    accountsConfig.accounts.splice(idx, 1);
+    // Update default if the removed domain was the default
+    if (accountsConfig.defaultDomain === domain) {
+        accountsConfig.defaultDomain = accountsConfig.accounts[0]?.domain;
+    }
+    saveAccounts(accountsConfig);
+    return true;
+}
+/**
+ * Add or update an account. Saves to disk with proper permissions.
+ */
+export function upsertAccount(info) {
+    loadAccounts();
+    const idx = accountsConfig.accounts.findIndex((a) => a.domain === info.domain);
+    if (idx >= 0) {
+        accountsConfig.accounts[idx] = info;
+    }
+    else {
+        accountsConfig.accounts.push(info);
+    }
+    // Set default if this is the first account
+    if (!accountsConfig.defaultDomain) {
+        accountsConfig.defaultDomain = info.domain;
+    }
+    saveAccounts(accountsConfig);
+}
+// Initialize accounts on startup
+loadAccounts();
+//# 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,23 @@
+/**
+ * Freshdesk API HTTP client.
+ *
+ * Centralises Basic auth header injection, error handling, rate-limit
+ * messaging, and domain URL construction for all Freshdesk API calls.
+ *
+ * Auth: Authorization: Basic base64(apiKey:X)
+ * Base URL: https://{domain}.freshdesk.com/api/v2
+ */
+export interface FreshdeskFetchOptions extends RequestInit {
+    params?: Record<string, string | number | boolean | undefined>;
+}
+/**
+ * Make an authenticated request to the Freshdesk API.
+ *
+ * @param domain   Freshdesk subdomain (e.g. "acme")
+ * @param apiKey   Freshdesk API key
+ * @param endpoint Path relative to /api/v2, e.g. '/tickets'
+ * @param options  Additional fetch options (method, body, headers, params)
+ * @returns Parsed JSON response
+ */
+export declare function freshdeskFetch<T>(domain: string, apiKey: string, endpoint: string, options?: FreshdeskFetchOptions): Promise<T>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.js

@@ -0,0 +1,93 @@
+/**
+ * Freshdesk API HTTP client.
+ *
+ * Centralises Basic auth header injection, error handling, rate-limit
+ * messaging, and domain URL construction for all Freshdesk API calls.
+ *
+ * Auth: Authorization: Basic base64(apiKey:X)
+ * Base URL: https://{domain}.freshdesk.com/api/v2
+ */
+import { FreshdeskError, REQUEST_TIMEOUT_MS } from './types.js';
+/**
+ * Make an authenticated request to the Freshdesk API.
+ *
+ * @param domain   Freshdesk subdomain (e.g. "acme")
+ * @param apiKey   Freshdesk API key
+ * @param endpoint Path relative to /api/v2, e.g. '/tickets'
+ * @param options  Additional fetch options (method, body, headers, params)
+ * @returns Parsed JSON response
+ */
+export async function freshdeskFetch(domain, apiKey, endpoint, options = {}) {
+    const { params, ...fetchOptions } = options;
+    // Build URL with query params
+    let url = `https://${domain}.freshdesk.com/api/v2${endpoint}`;
+    if (params) {
+        const searchParams = new URLSearchParams();
+        for (const [key, value] of Object.entries(params)) {
+            if (value !== undefined) {
+                searchParams.append(key, String(value));
+            }
+        }
+        const queryString = searchParams.toString();
+        if (queryString) {
+            url += (url.includes('?') ? '&' : '?') + queryString;
+        }
+    }
+    // Build auth header: Basic base64("{apiKey}:X")
+    const authHeader = `Basic ${Buffer.from(`${apiKey}:X`).toString('base64')}`;
+    console.error(`[Freshdesk API] ${fetchOptions.method || 'GET'} ${url}`);
+    let response;
+    try {
+        response = await fetch(url, {
+            ...fetchOptions,
+            signal: fetchOptions.signal ?? AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            headers: {
+                Authorization: authHeader,
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                ...fetchOptions.headers,
+            },
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'TimeoutError') {
+            throw new FreshdeskError('Request to Freshdesk API timed out', 'TIMEOUT', 'The request took too long. Try again or check if the Freshdesk instance is available.');
+        }
+        throw error;
+    }
+    // Handle rate limiting
+    if (response.status === 429) {
+        const retryAfter = response.headers.get('Retry-After');
+        const waitTime = retryAfter ? `${retryAfter} seconds` : 'a moment';
+        throw new FreshdeskError(`Rate limited. Please wait ${waitTime} before retrying.`, 'RATE_LIMITED', `Wait ${waitTime} and try again. Freshdesk rate limits vary by plan (Blossom: 100/min, Estate: 400/min, Forest: 700/min).`);
+    }
+    // Handle auth errors
+    if (response.status === 401) {
+        throw new FreshdeskError('Authentication failed', 'AUTH_FAILED', 'API key is invalid or revoked. Check your Freshdesk API key, or reconnect in Mindstone settings.');
+    }
+    // Handle forbidden
+    if (response.status === 403) {
+        throw new FreshdeskError('Access forbidden', 'AUTH_FAILED', 'Your API key does not have permission for this operation. Check your Freshdesk plan and role.');
+    }
+    // Handle not found
+    if (response.status === 404) {
+        throw new FreshdeskError('Resource not found', 'NOT_FOUND', 'The requested resource does not exist or you do not have permission to access it.');
+    }
+    // Handle other errors
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => '');
+        console.error(`Freshdesk API error (${response.status}):`, errorText);
+        const statusMessage = response.status === 422
+            ? 'Validation error - check request parameters'
+            : response.status >= 500
+                ? 'Freshdesk server error - try again later'
+                : 'Request failed';
+        throw new FreshdeskError(`Freshdesk API error (${response.status}): ${statusMessage}`, 'API_ERROR', 'Check the request parameters and try again. If the problem persists, reconnect your Freshdesk account in Mindstone settings.');
+    }
+    // Handle 204 No Content
+    if (response.status === 204) {
+        return {};
+    }
+    return response.json();
+}
+//# sourceMappingURL=client.js.map

package/dist/formatters.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Response formatting helpers for Freshdesk ticket data.
+ */
+import type { FreshdeskTicket, FreshdeskConversation, FreshdeskTicketField } from './types.js';
+export declare function ticketUrl(domain: string, ticketId: number): string;
+export declare function formatTicketConcise(ticket: FreshdeskTicket, domain: string): string;
+export declare function formatTicketDetailed(ticket: FreshdeskTicket, domain: string): string;
+export declare function formatConversation(conv: FreshdeskConversation): string;
+export declare function formatTicketField(field: FreshdeskTicketField): string;
+//# sourceMappingURL=formatters.d.ts.map

package/dist/formatters.js

@@ -0,0 +1,46 @@
+/**
+ * Response formatting helpers for Freshdesk ticket data.
+ */
+import { statusToString, priorityToString, sourceToString } from './types.js';
+export function ticketUrl(domain, ticketId) {
+    return `https://${domain}.freshdesk.com/a/tickets/${ticketId}`;
+}
+export function formatTicketConcise(ticket, domain) {
+    const status = statusToString(ticket.status);
+    const priority = priorityToString(ticket.priority);
+    return `#${ticket.id}: ${ticket.subject} [${status}] (${priority}) — ${ticketUrl(domain, ticket.id)}`;
+}
+export function formatTicketDetailed(ticket, domain) {
+    return [
+        `Ticket #${ticket.id}`,
+        `URL: ${ticketUrl(domain, ticket.id)}`,
+        `Subject: ${ticket.subject}`,
+        `Status: ${statusToString(ticket.status)} (${ticket.status})`,
+        `Priority: ${priorityToString(ticket.priority)} (${ticket.priority})`,
+        `Source: ${sourceToString(ticket.source)}`,
+        ticket.type ? `Type: ${ticket.type}` : '',
+        `Requester ID: ${ticket.requester_id}`,
+        ticket.email ? `Requester Email: ${ticket.email}` : '',
+        ticket.responder_id ? `Assignee ID: ${ticket.responder_id}` : 'Assignee: unassigned',
+        ticket.group_id ? `Group ID: ${ticket.group_id}` : '',
+        `Created: ${ticket.created_at}`,
+        `Updated: ${ticket.updated_at}`,
+        ticket.due_by ? `Due by: ${ticket.due_by}` : '',
+        ticket.tags && ticket.tags.length > 0 ? `Tags: ${ticket.tags.join(', ')}` : '',
+        ticket.description_text ? `Description:\n${ticket.description_text}` : '',
+    ]
+        .filter(Boolean)
+        .join('\n');
+}
+export function formatConversation(conv) {
+    const type = conv.private ? 'Internal note' : conv.incoming ? 'Customer reply' : 'Agent reply';
+    const preview = (conv.body_text || conv.body || '').slice(0, 200);
+    const truncated = (conv.body_text || conv.body || '').length > 200 ? '...' : '';
+    return `[${conv.created_at}] ${type} (User ${conv.user_id}):\n${preview}${truncated}`;
+}
+export function formatTicketField(field) {
+    const required = field.required_for_agents ? ' [required for agents]' : '';
+    const closure = field.required_for_closure ? ' [required for closure]' : '';
+    return `${field.label} (ID: ${field.id}, name: ${field.name}, type: ${field.type})${required}${closure}`;
+}
+//# sourceMappingURL=formatters.js.map

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * Freshdesk MCP Server
+ *
+ * Provides Freshdesk Support integration via Model Context Protocol.
+ * Supports multi-account management with file-backed accounts.json.
+ *
+ * Environment variables:
+ * - FRESHDESK_CONFIG_PATH: Path to config directory containing accounts.json
+ * - MCP_HOST_BRIDGE_STATE: Path to host app bridge state file (optional)
+ * - MINDSTONE_REBEL_BRIDGE_STATE: Legacy bridge state path (optional)
+ */
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+/**
+ * Freshdesk MCP Server
+ *
+ * Provides Freshdesk Support integration via Model Context Protocol.
+ * Supports multi-account management with file-backed accounts.json.
+ *
+ * Environment variables:
+ * - FRESHDESK_CONFIG_PATH: Path to config directory containing accounts.json
+ * - MCP_HOST_BRIDGE_STATE: Path to host app bridge state file (optional)
+ * - MINDSTONE_REBEL_BRIDGE_STATE: Legacy bridge state path (optional)
+ */
+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('Freshdesk 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,13 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerConfigureTools, registerTicketTools, registerFieldTools } from './tools/index.js';
+export function createServer() {
+    const server = new McpServer({
+        name: 'freshdesk-mcp-server',
+        version: '0.1.0',
+    });
+    registerConfigureTools(server);
+    registerTicketTools(server);
+    registerFieldTools(server);
+    return server;
+}
+//# sourceMappingURL=server.js.map

package/dist/tools/configure.d.ts

@@ -0,0 +1,3 @@
+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,114 @@
+import { z } from 'zod';
+import { loadAccounts, getAccountsConfig, removeAccount, upsertAccount } from '../auth.js';
+import { bridgeRequest, BRIDGE_STATE_PATH } from '../bridge.js';
+import { FreshdeskError } from '../types.js';
+import { withErrorHandling } from '../utils.js';
+export function registerConfigureTools(server) {
+    // ── configure_freshdesk ─────────────────────────────────────────
+    server.registerTool('configure_freshdesk', {
+        description: 'Connect a Freshdesk account using API key authentication. ' +
+            'Provide the Freshdesk subdomain (e.g., "acme" for acme.freshdesk.com) and API key from Profile Settings. ' +
+            'The account is stored and available for other Freshdesk tools. ' +
+            'HOW TO FIND YOUR API KEY: Log in → Profile picture → Profile Settings → API Key (right side). ' +
+            'COMMON MISTAKES: Providing full URL instead of just the subdomain.',
+        inputSchema: z.object({
+            domain: z
+                .string()
+                .min(1)
+                .describe('Freshdesk subdomain (e.g. "acme" for acme.freshdesk.com)'),
+            api_key: z.string().min(1).describe('Freshdesk API key from Profile Settings'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const domain = args.domain.trim();
+        const apiKey = args.api_key.trim();
+        // If bridge is available, persist via bridge
+        if (BRIDGE_STATE_PATH) {
+            try {
+                const result = await bridgeRequest('/bundled/freshdesk/configure', {
+                    domain,
+                    apiKey,
+                });
+                if (result.success) {
+                    loadAccounts();
+                    const message = result.warning
+                        ? `Freshdesk account connected: ${domain}.freshdesk.com. Note: ${result.warning}`
+                        : `Freshdesk account connected: ${domain}.freshdesk.com`;
+                    return JSON.stringify({ ok: true, message, domain });
+                }
+                // Bridge returned failure — surface as error, do NOT fall through
+                throw new FreshdeskError(result.error || 'Bridge configuration failed', 'BRIDGE_ERROR', 'The host app bridge rejected the configuration request. Check the host app logs.');
+            }
+            catch (error) {
+                if (error instanceof FreshdeskError)
+                    throw error;
+                // Bridge request failed (network, timeout, etc.) — surface as error
+                throw new FreshdeskError(`Bridge request failed: ${error instanceof Error ? error.message : String(error)}`, 'BRIDGE_ERROR', 'Could not reach the host app bridge. Ensure the host app is running.');
+            }
+        }
+        // No bridge — store locally
+        upsertAccount({
+            domain,
+            apiKey,
+            authenticatedAt: new Date().toISOString(),
+        });
+        return JSON.stringify({
+            ok: true,
+            message: `Freshdesk account connected: ${domain}.freshdesk.com`,
+            domain,
+        });
+    }));
+    // ── list_freshdesk_accounts ─────────────────────────────────────
+    server.registerTool('list_freshdesk_accounts', {
+        description: 'List connected Freshdesk accounts. Returns all authenticated domains with associated agent emails. ' +
+            'Call this first to check connected accounts. If none, use configure_freshdesk.',
+        inputSchema: z.object({}),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async () => {
+        loadAccounts();
+        const config = getAccountsConfig();
+        if (config.accounts.length === 0) {
+            return JSON.stringify({
+                ok: true,
+                accounts: [],
+                message: 'No Freshdesk accounts connected. Use configure_freshdesk or go to Mindstone Settings > Integrations > Freshdesk to connect.',
+            });
+        }
+        const accountList = config.accounts.map((account) => ({
+            domain: account.domain,
+            agentEmail: account.agentEmail || 'unknown',
+            url: `https://${account.domain}.freshdesk.com`,
+            authenticatedAt: account.authenticatedAt,
+            status: 'active',
+        }));
+        return JSON.stringify({
+            ok: true,
+            accounts: accountList,
+            defaultDomain: config.defaultDomain,
+        });
+    }));
+    // ── remove_freshdesk_account ────────────────────────────────────
+    server.registerTool('remove_freshdesk_account', {
+        description: 'Disconnect a Freshdesk account. Removes stored credentials for the specified domain. ' +
+            'Use list_freshdesk_accounts to see available domains.',
+        inputSchema: z.object({
+            domain: z.string().min(1).describe('Freshdesk domain to disconnect (e.g. "acme")'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: true },
+    }, withErrorHandling(async (args) => {
+        const domain = args.domain.trim();
+        const removed = removeAccount(domain);
+        if (!removed) {
+            return JSON.stringify({
+                ok: false,
+                error: `No account found for domain "${domain}".`,
+                resolution: 'Use list_freshdesk_accounts to see available domains.',
+            });
+        }
+        return JSON.stringify({
+            ok: true,
+            message: `Disconnected ${domain}.freshdesk.com`,
+        });
+    }));
+}
+//# sourceMappingURL=configure.js.map

package/dist/tools/fields.d.ts

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

package/dist/tools/fields.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { getAccount } from '../auth.js';
+import { freshdeskFetch } from '../client.js';
+import { formatTicketField } from '../formatters.js';
+import { withErrorHandling } from '../utils.js';
+export function registerFieldTools(server) {
+    server.registerTool('list_freshdesk_ticket_fields', {
+        description: 'List all ticket fields including custom fields. Returns field IDs, names, types, and options. ' +
+            'Essential for finding custom field names for create/update operations.',
+        inputSchema: z.object({
+            domain: z.string().optional().describe('Freshdesk domain (optional if only one account)'),
+            response_format: z
+                .enum(['concise', 'detailed'])
+                .optional()
+                .describe('Response format (default: "concise")'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const account = getAccount(args.domain);
+        if (!account) {
+            return JSON.stringify({
+                ok: false,
+                error: 'No Freshdesk account connected',
+                resolution: 'Use configure_freshdesk or go to Mindstone Settings > Integrations > Freshdesk to connect your account.',
+            });
+        }
+        const fields = await freshdeskFetch(account.domain, account.apiKey, '/admin/ticket_fields');
+        const format = args.response_format || 'concise';
+        if (format === 'concise') {
+            const lines = fields.map(formatTicketField);
+            return `Ticket Fields (${fields.length}):\n${lines.join('\n')}`;
+        }
+        return JSON.stringify({
+            ok: true,
+            ticket_fields: fields,
+            count: fields.length,
+        });
+    }));
+}
+//# sourceMappingURL=fields.js.map

package/dist/tools/index.d.ts

@@ -0,0 +1,4 @@
+export { registerConfigureTools } from './configure.js';
+export { registerTicketTools } from './tickets.js';
+export { registerFieldTools } from './fields.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -0,0 +1,4 @@
+export { registerConfigureTools } from './configure.js';
+export { registerTicketTools } from './tickets.js';
+export { registerFieldTools } from './fields.js';
+//# sourceMappingURL=index.js.map

package/dist/tools/tickets.d.ts

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

package/dist/tools/tickets.js

@@ -0,0 +1,344 @@
+import { z } from 'zod';
+import { getAccount } from '../auth.js';
+import { freshdeskFetch } from '../client.js';
+import { parseStatus, parsePriority, } from '../types.js';
+import { ticketUrl, formatTicketConcise, formatTicketDetailed, formatConversation, } from '../formatters.js';
+import { withErrorHandling } from '../utils.js';
+function noAccountError() {
+    return JSON.stringify({
+        ok: false,
+        error: 'No Freshdesk account connected',
+        resolution: 'Use configure_freshdesk or go to Mindstone Settings > Integrations > Freshdesk to connect your account.',
+    });
+}
+export function registerTicketTools(server) {
+    // ── list_freshdesk_tickets ──────────────────────────────────────
+    server.registerTool('list_freshdesk_tickets', {
+        description: 'List Freshdesk tickets using predefined filters. Default: "new_and_my_open". ' +
+            'For attribute-based search, use search_freshdesk_tickets instead. ' +
+            'FILTERS: new_and_my_open, watching, spam, deleted. Max 30 per page.',
+        inputSchema: z.object({
+            domain: z.string().optional().describe('Freshdesk domain (optional if only one account)'),
+            filter: z
+                .enum(['new_and_my_open', 'watching', 'spam', 'deleted'])
+                .optional()
+                .describe('Predefined filter (default: "new_and_my_open")'),
+            per_page: z.number().optional().describe('Results per page, max 30 (default: 30)'),
+            page: z.number().optional().describe('Page number (default: 1)'),
+            response_format: z
+                .enum(['concise', 'detailed'])
+                .optional()
+                .describe('Response format (default: "concise")'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const account = getAccount(args.domain);
+        if (!account)
+            return noAccountError();
+        const filter = args.filter || 'new_and_my_open';
+        const perPage = Math.min(args.per_page || 30, 30);
+        const page = args.page || 1;
+        const tickets = await freshdeskFetch(account.domain, account.apiKey, '/tickets', { params: { filter, per_page: perPage, page } });
+        const format = args.response_format || 'concise';
+        if (format === 'concise') {
+            if (tickets.length === 0) {
+                return `No tickets found for filter "${filter}".`;
+            }
+            const lines = tickets.map((t) => formatTicketConcise(t, account.domain));
+            const moreHint = tickets.length >= perPage
+                ? '\n\n(More results may be available — increase page number)'
+                : '';
+            return `Tickets (${tickets.length}, filter: ${filter}):\n\n${lines.join('\n')}${moreHint}`;
+        }
+        return JSON.stringify({
+            ok: true,
+            tickets,
+            count: tickets.length,
+            filter,
+            page,
+            hasMore: tickets.length >= perPage,
+        });
+    }));
+    // ── get_freshdesk_ticket ────────────────────────────────────────
+    server.registerTool('get_freshdesk_ticket', {
+        description: 'Get a single Freshdesk ticket by ID with optional conversations. ' +
+            'Set include_conversations to true to fetch the conversation thread (replies and notes).',
+        inputSchema: z.object({
+            ticket_id: z.number().describe('Ticket ID'),
+            domain: z.string().optional().describe('Freshdesk domain (optional if only one account)'),
+            include_conversations: z
+                .boolean()
+                .optional()
+                .describe('Include ticket conversations (default: false)'),
+            response_format: z
+                .enum(['concise', 'detailed'])
+                .optional()
+                .describe('Response format (default: "detailed")'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const account = getAccount(args.domain);
+        if (!account)
+            return noAccountError();
+        const includeConversations = args.include_conversations === true;
+        const ticketEndpoint = includeConversations
+            ? `/tickets/${args.ticket_id}?include=conversations`
+            : `/tickets/${args.ticket_id}`;
+        const ticket = await freshdeskFetch(account.domain, account.apiKey, ticketEndpoint);
+        let conversations;
+        if (includeConversations) {
+            if (ticket.conversations && Array.isArray(ticket.conversations)) {
+                conversations = ticket.conversations;
+            }
+            else {
+                conversations = await freshdeskFetch(account.domain, account.apiKey, `/tickets/${args.ticket_id}/conversations`);
+            }
+        }
+        const format = args.response_format || 'detailed';
+        if (format === 'concise') {
+            let result = formatTicketConcise(ticket, account.domain);
+            if (conversations && conversations.length > 0) {
+                result += `\n\nConversations (${conversations.length}):\n`;
+                result += conversations.map((c) => formatConversation(c)).join('\n\n');
+            }
+            return result;
+        }
+        let result = formatTicketDetailed(ticket, account.domain);
+        if (conversations && conversations.length > 0) {
+            result += `\n\n--- Conversations (${conversations.length}) ---\n\n`;
+            result += conversations.map((c) => formatConversation(c)).join('\n\n');
+        }
+        return result;
+    }));
+    // ── search_freshdesk_tickets ────────────────────────────────────
+    server.registerTool('search_freshdesk_tickets', {
+        description: 'Search Freshdesk tickets using Freshdesk query syntax. ' +
+            'QUERY SYNTAX: "status:2", "priority:4", "tag:\'billing\'", "requester.email:\'john@acme.com\'". ' +
+            'Combine with AND/OR. Auto-wraps query in quotes if needed.',
+        inputSchema: z.object({
+            query: z.string().min(1).describe('Freshdesk search query (e.g. "status:2 AND priority:4")'),
+            domain: z.string().optional().describe('Freshdesk domain (optional if only one account)'),
+            page: z.number().optional().describe('Page number (default: 1)'),
+            response_format: z
+                .enum(['concise', 'detailed'])
+                .optional()
+                .describe('Response format (default: "concise")'),
+        }),
+        annotations: { readOnlyHint: true },
+    }, withErrorHandling(async (args) => {
+        const account = getAccount(args.domain);
+        if (!account)
+            return noAccountError();
+        let query = args.query.trim();
+        // Auto-wrap query in quotes if not already quoted
+        if (!query.startsWith('"')) {
+            query = `"${query}"`;
+        }
+        const page = args.page || 1;
+        const response = await freshdeskFetch(account.domain, account.apiKey, '/search/tickets', { params: { query, page } });
+        const format = args.response_format || 'concise';
+        const total = response.total;
+        const hasMore = total > page * 30;
+        if (format === 'concise') {
+            if (response.results.length === 0) {
+                return `No tickets found for query: ${query}`;
+            }
+            const lines = response.results.map((t) => formatTicketConcise(t, account.domain));
+            return `Search results (${response.results.length} of ${total})${hasMore ? ' — more available' : ''}:\n\n${lines.join('\n')}`;
+        }
+        return JSON.stringify({
+            ok: true,
+            tickets: response.results,
+            count: response.results.length,
+            total,
+            page,
+            hasMore,
+        });
+    }));
+    // ── create_freshdesk_ticket ─────────────────────────────────────
+    server.registerTool('create_freshdesk_ticket', {
+        description: 'Create a new Freshdesk ticket. Required: email, subject, description (HTML body). ' +
+            'PRIORITY: 1=Low, 2=Medium, 3=High, 4=Urgent (or names). ' +
+            'STATUS: 2=Open, 3=Pending, 4=Resolved, 5=Closed (or names).',
+        inputSchema: z.object({
+            email: z.string().min(1).describe('Requester email address (required)'),
+            subject: z.string().min(1).describe('Ticket subject line'),
+            description: z.string().min(1).describe('Ticket description (HTML supported)'),
+            domain: z.string().optional().describe('Freshdesk domain (optional if only one account)'),
+            priority: z
+                .union([z.number(), z.string()])
+                .optional()
+                .describe('Priority: 1=Low, 2=Medium, 3=High, 4=Urgent (or names)'),
+            status: z
+                .union([z.number(), z.string()])
+                .optional()
+                .describe('Status: 2=Open, 3=Pending, 4=Resolved, 5=Closed (or names)'),
+            type: z.string().optional().describe('Ticket type (e.g. "Bug", "Question")'),
+            tags: z.array(z.string()).optional().describe('Tags to apply'),
+            responder_id: z.number().optional().describe('Agent ID to assign ticket to'),
+            group_id: z.number().optional().describe('Group ID to assign ticket to'),
+            custom_fields: z
+                .record(z.unknown())
+                .optional()
+                .describe('Custom field values as key-value pairs'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const account = getAccount(args.domain);
+        if (!account)
+            return noAccountError();
+        const payload = {
+            email: args.email,
+            subject: args.subject,
+            description: args.description,
+        };
+        if (args.priority !== undefined) {
+            const p = parsePriority(args.priority);
+            if (p !== undefined)
+                payload.priority = p;
+        }
+        if (args.status !== undefined) {
+            const s = parseStatus(args.status);
+            if (s !== undefined)
+                payload.status = s;
+        }
+        if (args.type)
+            payload.type = args.type;
+        if (args.tags)
+            payload.tags = args.tags;
+        if (args.responder_id)
+            payload.responder_id = args.responder_id;
+        if (args.group_id)
+            payload.group_id = args.group_id;
+        if (args.custom_fields)
+            payload.custom_fields = args.custom_fields;
+        const ticket = await freshdeskFetch(account.domain, account.apiKey, '/tickets', { method: 'POST', body: JSON.stringify(payload) });
+        return JSON.stringify({
+            ok: true,
+            message: `Created ticket #${ticket.id}`,
+            ticket: {
+                id: ticket.id,
+                subject: ticket.subject,
+                status: ticket.status,
+                priority: ticket.priority,
+                url: ticketUrl(account.domain, ticket.id),
+            },
+        });
+    }));
+    // ── update_freshdesk_ticket ─────────────────────────────────────
+    server.registerTool('update_freshdesk_ticket', {
+        description: 'Update an existing Freshdesk ticket. Can update status, priority, assignee, type, tags, custom fields. ' +
+            'For replies use reply_to_freshdesk_ticket; for notes use add_freshdesk_note.',
+        inputSchema: z.object({
+            ticket_id: z.number().describe('Ticket ID to update'),
+            domain: z.string().optional().describe('Freshdesk domain (optional if only one account)'),
+            status: z
+                .union([z.number(), z.string()])
+                .optional()
+                .describe('New status: 2=Open, 3=Pending, 4=Resolved, 5=Closed (or names)'),
+            priority: z
+                .union([z.number(), z.string()])
+                .optional()
+                .describe('New priority: 1=Low, 2=Medium, 3=High, 4=Urgent (or names)'),
+            type: z.string().optional().describe('New ticket type'),
+            responder_id: z.number().optional().describe('New assignee agent ID'),
+            group_id: z.number().optional().describe('New group ID'),
+            tags: z.array(z.string()).optional().describe('Replace all tags with this list'),
+            custom_fields: z
+                .record(z.unknown())
+                .optional()
+                .describe('Custom field updates as key-value pairs'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const account = getAccount(args.domain);
+        if (!account)
+            return noAccountError();
+        const payload = {};
+        if (args.status !== undefined) {
+            const s = parseStatus(args.status);
+            if (s !== undefined)
+                payload.status = s;
+        }
+        if (args.priority !== undefined) {
+            const p = parsePriority(args.priority);
+            if (p !== undefined)
+                payload.priority = p;
+        }
+        if (args.type)
+            payload.type = args.type;
+        if (args.responder_id)
+            payload.responder_id = args.responder_id;
+        if (args.group_id)
+            payload.group_id = args.group_id;
+        if (args.tags)
+            payload.tags = args.tags;
+        if (args.custom_fields)
+            payload.custom_fields = args.custom_fields;
+        const ticket = await freshdeskFetch(account.domain, account.apiKey, `/tickets/${args.ticket_id}`, { method: 'PUT', body: JSON.stringify(payload) });
+        return JSON.stringify({
+            ok: true,
+            message: `Updated ticket #${args.ticket_id}`,
+            ticket: {
+                id: ticket.id,
+                subject: ticket.subject,
+                status: ticket.status,
+                priority: ticket.priority,
+                url: ticketUrl(account.domain, ticket.id),
+            },
+        });
+    }));
+    // ── reply_to_freshdesk_ticket ───────────────────────────────────
+    server.registerTool('reply_to_freshdesk_ticket', {
+        description: 'Add a public reply to a Freshdesk ticket. The reply is visible to the customer. ' +
+            'For internal notes use add_freshdesk_note instead.',
+        inputSchema: z.object({
+            ticket_id: z.number().describe('Ticket ID to reply to'),
+            body: z.string().min(1).describe('Reply body (HTML supported)'),
+            domain: z.string().optional().describe('Freshdesk domain (optional if only one account)'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const account = getAccount(args.domain);
+        if (!account)
+            return noAccountError();
+        await freshdeskFetch(account.domain, account.apiKey, `/tickets/${args.ticket_id}/reply`, {
+            method: 'POST',
+            body: JSON.stringify({ body: args.body }),
+        });
+        return JSON.stringify({
+            ok: true,
+            message: `Added public reply to ticket #${args.ticket_id}`,
+            url: ticketUrl(account.domain, args.ticket_id),
+        });
+    }));
+    // ── add_freshdesk_note ──────────────────────────────────────────
+    server.registerTool('add_freshdesk_note', {
+        description: 'Add a note to a Freshdesk ticket. Default: private (agents only). ' +
+            'Set private to false for a note visible to the requester. ' +
+            'For public replies use reply_to_freshdesk_ticket.',
+        inputSchema: z.object({
+            ticket_id: z.number().describe('Ticket ID to add note to'),
+            body: z.string().min(1).describe('Note body (HTML supported)'),
+            domain: z.string().optional().describe('Freshdesk domain (optional if only one account)'),
+            private: z.boolean().optional().describe('Private note (default: true)'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withErrorHandling(async (args) => {
+        const account = getAccount(args.domain);
+        if (!account)
+            return noAccountError();
+        const isPrivate = args.private !== false;
+        await freshdeskFetch(account.domain, account.apiKey, `/tickets/${args.ticket_id}/notes`, {
+            method: 'POST',
+            body: JSON.stringify({ body: args.body, private: isPrivate }),
+        });
+        const visibility = isPrivate ? 'private note' : 'public note';
+        return JSON.stringify({
+            ok: true,
+            message: `Added ${visibility} to ticket #${args.ticket_id}`,
+            url: ticketUrl(account.domain, args.ticket_id),
+        });
+    }));
+}
+//# sourceMappingURL=tickets.js.map

package/dist/types.d.ts

@@ -0,0 +1,87 @@
+export declare const REQUEST_TIMEOUT_MS = 30000;
+export interface BridgeState {
+    port: number;
+    token: string;
+}
+export declare class FreshdeskError extends Error {
+    readonly code: string;
+    readonly resolution: string;
+    constructor(message: string, code: string, resolution: string);
+}
+export interface AccountInfo {
+    domain: string;
+    apiKey: string;
+    agentEmail?: string;
+    authenticatedAt?: string;
+}
+export interface AccountsConfig {
+    accounts: AccountInfo[];
+    defaultDomain?: string;
+}
+export interface FreshdeskAccount {
+    domain: string;
+    apiKey: string;
+    agentEmail?: string;
+}
+export interface FreshdeskTicket {
+    id: number;
+    subject: string;
+    description?: string;
+    description_text?: string;
+    status: number;
+    priority: number;
+    source: number;
+    type?: string;
+    requester_id: number;
+    responder_id?: number;
+    group_id?: number;
+    email?: string;
+    created_at: string;
+    updated_at: string;
+    due_by?: string;
+    tags?: string[];
+    custom_fields?: Record<string, unknown>;
+    fr_escalated?: boolean;
+    spam?: boolean;
+    is_escalated?: boolean;
+}
+export interface FreshdeskConversation {
+    id: number;
+    body: string;
+    body_text?: string;
+    incoming: boolean;
+    private: boolean;
+    user_id: number;
+    from_email?: string;
+    to_emails?: string[];
+    created_at: string;
+    updated_at: string;
+    source: number;
+}
+export interface FreshdeskTicketField {
+    id: number;
+    name: string;
+    label: string;
+    description?: string;
+    type: string;
+    required_for_closure: boolean;
+    required_for_agents: boolean;
+    default: boolean;
+    position: number;
+    choices?: Record<string, unknown> | Array<string | [string, string]>;
+}
+export declare const STATUS_MAP: Record<number, string>;
+export declare const PRIORITY_MAP: Record<number, string>;
+export declare const SOURCE_MAP: Record<number, string>;
+export declare function statusToString(status: number): string;
+export declare function priorityToString(priority: number): string;
+export declare function sourceToString(source: number): string;
+/**
+ * Parse a status value that may be a number or a human-readable string.
+ */
+export declare function parseStatus(input: unknown): number | undefined;
+/**
+ * Parse a priority value that may be a number or a human-readable string.
+ */
+export declare function parsePriority(input: unknown): number | undefined;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,80 @@
+export const REQUEST_TIMEOUT_MS = 30_000;
+export class FreshdeskError extends Error {
+    code;
+    resolution;
+    constructor(message, code, resolution) {
+        super(message);
+        this.code = code;
+        this.resolution = resolution;
+        this.name = 'FreshdeskError';
+    }
+}
+// ---------------------------------------------------------------------------
+// Status / Priority / Source maps
+// ---------------------------------------------------------------------------
+export const STATUS_MAP = {
+    2: 'Open',
+    3: 'Pending',
+    4: 'Resolved',
+    5: 'Closed',
+};
+export const PRIORITY_MAP = {
+    1: 'Low',
+    2: 'Medium',
+    3: 'High',
+    4: 'Urgent',
+};
+export const SOURCE_MAP = {
+    1: 'Email',
+    2: 'Portal',
+    3: 'Phone',
+    7: 'Chat',
+    8: 'Feedback Widget',
+    9: 'Outbound Email',
+};
+export function statusToString(status) {
+    return STATUS_MAP[status] || `Custom (${status})`;
+}
+export function priorityToString(priority) {
+    return PRIORITY_MAP[priority] || `Unknown (${priority})`;
+}
+export function sourceToString(source) {
+    return SOURCE_MAP[source] || `Unknown (${source})`;
+}
+/**
+ * Parse a status value that may be a number or a human-readable string.
+ */
+export function parseStatus(input) {
+    if (typeof input === 'number')
+        return input;
+    if (typeof input === 'string') {
+        const num = parseInt(input, 10);
+        if (!isNaN(num))
+            return num;
+        const lower = input.toLowerCase();
+        for (const [key, value] of Object.entries(STATUS_MAP)) {
+            if (value.toLowerCase() === lower)
+                return parseInt(key, 10);
+        }
+    }
+    return undefined;
+}
+/**
+ * Parse a priority value that may be a number or a human-readable string.
+ */
+export function parsePriority(input) {
+    if (typeof input === 'number')
+        return input;
+    if (typeof input === 'string') {
+        const num = parseInt(input, 10);
+        if (!isNaN(num))
+            return num;
+        const lower = input.toLowerCase();
+        for (const [key, value] of Object.entries(PRIORITY_MAP)) {
+            if (value.toLowerCase() === lower)
+                return parseInt(key, 10);
+        }
+    }
+    return undefined;
+}
+//# 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 FreshdeskError: 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 { FreshdeskError } from './types.js';
+/**
+ * Wraps a tool handler with standard error handling.
+ *
+ * - On success: returns the string result as a text content block.
+ * - On FreshdeskError: 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 FreshdeskError) {
+                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-freshdesk",
+  "version": "0.1.0",
+  "description": "Freshdesk Support MCP server for Model Context Protocol hosts",
+  "license": "FSL-1.1-MIT",
+  "type": "module",
+  "bin": {
+    "mcp-server-freshdesk": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nspr-io/mcp-servers.git",
+    "directory": "connectors/freshdesk"
+  },
+  "homepage": "https://github.com/nspr-io/mcp-servers/tree/main/connectors/freshdesk",
+  "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"
+  }
+}