daeda-mcp 1.0.0

package/dist/sync/init-state.js

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DATA_DIR = join(__dirname, "..", "..", "data");
+const STATE_FILE = join(DATA_DIR, "init_state.json");
+export const ALL_EXPORTS = [
+    "contacts",
+    "companies",
+    "deals",
+    "contact_company",
+    "deal_contact",
+    "deal_company",
+];
+function createEmptyExportState() {
+    return {
+        exportId: null,
+        status: "pending",
+        error: null,
+    };
+}
+export function createInitialState() {
+    return {
+        status: "idle",
+        exports: {
+            contacts: createEmptyExportState(),
+            companies: createEmptyExportState(),
+            deals: createEmptyExportState(),
+            contact_company: createEmptyExportState(),
+            deal_contact: createEmptyExportState(),
+            deal_company: createEmptyExportState(),
+        },
+        startedAt: null,
+        error: null,
+    };
+}
+export function readInitState() {
+    try {
+        if (!existsSync(STATE_FILE)) {
+            return createInitialState();
+        }
+        const content = readFileSync(STATE_FILE, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return createInitialState();
+    }
+}
+export function writeInitState(state) {
+    mkdirSync(DATA_DIR, { recursive: true });
+    writeFileSync(STATE_FILE, JSON.stringify(state, null, 2), "utf-8");
+}
+export function resetInitState() {
+    writeInitState(createInitialState());
+}
+export function getSyncedCount(state) {
+    return ALL_EXPORTS.filter((name) => state.exports[name].status === "synced").length;
+}
+export function isFullySynced(state) {
+    return getSyncedCount(state) === ALL_EXPORTS.length;
+}
+export function getStateFilePath() {
+    return STATE_FILE;
+}

package/dist/sync/seeder.d.ts

@@ -0,0 +1 @@
+export declare function runSeeding(token: string): Promise<void>;

package/dist/sync/seeder.js

@@ -0,0 +1,176 @@
+import { batchInsertDeals, batchInsertContacts, batchInsertCompanies, batchInsertAssociations, } from "../db/sqlite.js";
+import { readInitState, writeInitState, } from "./init-state.js";
+const HUBSPOT_API_BASE = "https://api.hubapi.com";
+const SEED_LIMIT = 1000;
+const BATCH_SIZE = 100;
+async function apiRequest(token, method, path, body) {
+    const response = await fetch(`${HUBSPOT_API_BASE}${path}`, {
+        method,
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+        },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`HubSpot API error (${response.status}): ${errorText}`);
+    }
+    return response.json();
+}
+async function searchRecentDeals(token, limit = SEED_LIMIT) {
+    const deals = [];
+    let after;
+    while (deals.length < limit) {
+        const pageSize = Math.min(BATCH_SIZE, limit - deals.length);
+        const body = {
+            limit: pageSize,
+            sorts: [{ propertyName: "hs_lastmodifieddate", direction: "DESCENDING" }],
+            properties: ["dealname", "amount", "dealstage", "closedate", "pipeline", "hs_lastmodifieddate"],
+        };
+        if (after) {
+            body.after = after;
+        }
+        const response = await apiRequest(token, "POST", "/crm/v3/objects/deals/search", body);
+        deals.push(...response.results);
+        if (!response.paging?.next?.after || response.results.length < pageSize) {
+            break;
+        }
+        after = response.paging.next.after;
+    }
+    return deals;
+}
+async function batchGetAssociations(token, fromObjectType, toObjectType, objectIds) {
+    const associations = new Map();
+    for (let i = 0; i < objectIds.length; i += BATCH_SIZE) {
+        const batch = objectIds.slice(i, i + BATCH_SIZE);
+        const body = {
+            inputs: batch.map((id) => ({ id })),
+        };
+        const response = await apiRequest(token, "POST", `/crm/v4/associations/${fromObjectType}/${toObjectType}/batch/read`, body);
+        for (const result of response.results) {
+            const fromId = result.from.id;
+            const toIds = result.to.map((t) => t.toObjectId);
+            associations.set(fromId, toIds);
+        }
+    }
+    return associations;
+}
+async function batchReadObjects(token, objectType, objectIds, properties) {
+    const uniqueIds = [...new Set(objectIds)];
+    const objects = [];
+    for (let i = 0; i < uniqueIds.length; i += BATCH_SIZE) {
+        const batch = uniqueIds.slice(i, i + BATCH_SIZE);
+        const body = {
+            inputs: batch.map((id) => ({ id })),
+            properties,
+        };
+        const response = await apiRequest(token, "POST", `/crm/v3/objects/${objectType}/batch/read`, body);
+        objects.push(...response.results);
+    }
+    return objects;
+}
+function updateSeedingProgress(deals, contacts, companies) {
+    const state = readInitState();
+    state.seedingProgress = { deals, contacts, companies };
+    writeInitState(state);
+}
+function updateSeedingStatus(status, error) {
+    const state = readInitState();
+    state.seedingStatus = status;
+    if (error) {
+        state.seedingError = error;
+    }
+    writeInitState(state);
+}
+export async function runSeeding(token) {
+    console.error("[seeder] Starting quick seed of recent deals...");
+    updateSeedingStatus("in_progress");
+    updateSeedingProgress(0, 0, 0);
+    try {
+        console.error("[seeder] Fetching 1,000 most recently modified deals...");
+        const deals = await searchRecentDeals(token, SEED_LIMIT);
+        console.error(`[seeder] Found ${deals.length} deals`);
+        if (deals.length === 0) {
+            console.error("[seeder] No deals found, skipping seed");
+            updateSeedingStatus("completed");
+            return;
+        }
+        const dealIds = deals.map((d) => d.id);
+        const dealRows = deals.map((d) => ({
+            id: d.id,
+            dealname: d.properties.dealname || null,
+            properties: d.properties,
+        }));
+        await batchInsertDeals(dealRows);
+        updateSeedingProgress(dealRows.length, 0, 0);
+        console.error(`[seeder] Inserted ${dealRows.length} deals`);
+        console.error("[seeder] Fetching deal-contact associations...");
+        const dealContactAssocs = await batchGetAssociations(token, "deals", "contacts", dealIds);
+        console.error("[seeder] Fetching deal-company associations...");
+        const dealCompanyAssocs = await batchGetAssociations(token, "deals", "companies", dealIds);
+        const contactIds = new Set();
+        const companyIds = new Set();
+        for (const [dealId, contacts] of dealContactAssocs) {
+            for (const contactId of contacts) {
+                contactIds.add(contactId);
+            }
+        }
+        for (const [dealId, companies] of dealCompanyAssocs) {
+            for (const companyId of companies) {
+                companyIds.add(companyId);
+            }
+        }
+        console.error(`[seeder] Found ${contactIds.size} unique contacts, ${companyIds.size} unique companies`);
+        let contactsInserted = 0;
+        if (contactIds.size > 0) {
+            console.error("[seeder] Fetching contact records...");
+            const contacts = await batchReadObjects(token, "contacts", [...contactIds], ["email", "firstname", "lastname", "phone", "company", "jobtitle", "hs_lastmodifieddate"]);
+            const contactRows = contacts.map((c) => ({
+                id: c.id,
+                email: c.properties.email || null,
+                properties: c.properties,
+            }));
+            await batchInsertContacts(contactRows);
+            contactsInserted = contactRows.length;
+            console.error(`[seeder] Inserted ${contactRows.length} contacts`);
+        }
+        updateSeedingProgress(dealRows.length, contactsInserted, 0);
+        let companiesInserted = 0;
+        if (companyIds.size > 0) {
+            console.error("[seeder] Fetching company records...");
+            const companies = await batchReadObjects(token, "companies", [...companyIds], ["domain", "name", "industry", "city", "state", "country", "hs_lastmodifieddate"]);
+            const companyRows = companies.map((c) => ({
+                id: c.id,
+                domain: c.properties.domain || null,
+                properties: c.properties,
+            }));
+            await batchInsertCompanies(companyRows);
+            companiesInserted = companyRows.length;
+            console.error(`[seeder] Inserted ${companyRows.length} companies`);
+        }
+        updateSeedingProgress(dealRows.length, contactsInserted, companiesInserted);
+        console.error("[seeder] Inserting associations...");
+        const dealContactRows = [];
+        for (const [dealId, contacts] of dealContactAssocs) {
+            for (const contactId of contacts) {
+                dealContactRows.push({ fromId: dealId, toId: contactId });
+            }
+        }
+        await batchInsertAssociations("deal_contact", dealContactRows);
+        const dealCompanyRows = [];
+        for (const [dealId, companies] of dealCompanyAssocs) {
+            for (const companyId of companies) {
+                dealCompanyRows.push({ fromId: dealId, toId: companyId });
+            }
+        }
+        await batchInsertAssociations("deal_company", dealCompanyRows);
+        console.error(`[seeder] Seeding complete: ${dealRows.length} deals, ${contactsInserted} contacts, ${companiesInserted} companies`);
+        updateSeedingStatus("completed");
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        console.error("[seeder] Seeding failed:", errMsg);
+        updateSeedingStatus("error", errMsg);
+    }
+}

package/dist/tools/auth.d.ts

@@ -0,0 +1,26 @@
+import { type SeedingStatus, type SeedingProgress } from "../sync/init-state.js";
+export interface DbStatusResult {
+    status: "not_started" | "sending_requests" | "seeding" | "syncing" | "ready" | "error";
+    syncProgress?: string;
+    exportDetails?: Record<string, {
+        status: string;
+        error?: string;
+    }>;
+    seedingStatus?: SeedingStatus;
+    seedingProgress?: SeedingProgress;
+    seedingError?: string;
+    hasToken: boolean;
+    lastSynced?: string | null;
+    initializedAt?: string | null;
+    recordCounts?: {
+        contacts: number;
+        companies: number;
+        deals: number;
+        contact_company: number;
+        deal_contact: number;
+        deal_company: number;
+    };
+    error?: string | null;
+    message?: string;
+}
+export declare function dbStatus(forceReinit?: boolean): Promise<string>;

package/dist/tools/auth.js

@@ -0,0 +1,127 @@
+import { getHubSpotToken } from "../db/keychain.js";
+import { dbExists, isDbHealthy, getRecordCount, getAllMetadata, } from "../db/sqlite.js";
+import { getInitStatus, forceReinitialize, } from "../sync/init-manager.js";
+import { getSyncedCount, ALL_EXPORTS } from "../sync/init-state.js";
+export async function dbStatus(forceReinit = false) {
+    if (forceReinit) {
+        forceReinitialize();
+        return JSON.stringify({
+            status: "sending_requests",
+            syncProgress: "0/6 exports synced",
+            hasToken: !!getHubSpotToken(),
+            message: "Re-initialization started. Poll db_status to track progress.",
+        });
+    }
+    const initState = getInitStatus();
+    const hasToken = !!getHubSpotToken();
+    if (initState.status === "idle") {
+        return JSON.stringify({
+            status: "not_started",
+            hasToken,
+            message: "Database initialization not started. Server will auto-start on next restart.",
+        });
+    }
+    if (initState.status === "sending_requests") {
+        return JSON.stringify({
+            status: "sending_requests",
+            syncProgress: "0/6 exports synced",
+            hasToken,
+            message: "Sending export requests to HubSpot...",
+        });
+    }
+    if (initState.status === "polling_exports") {
+        const syncedCount = getSyncedCount(initState);
+        const exportDetails = {};
+        for (const name of ALL_EXPORTS) {
+            const exp = initState.exports[name];
+            exportDetails[name] = {
+                status: exp.status,
+                ...(exp.error && { error: exp.error }),
+            };
+        }
+        const seedingStatus = initState.seedingStatus;
+        const seedingProgress = initState.seedingProgress;
+        const seedingError = initState.seedingError;
+        let message = `Syncing HubSpot data... ${syncedCount} of ${ALL_EXPORTS.length} exports complete.`;
+        if (seedingStatus === "in_progress" && seedingProgress) {
+            message = `Quick preview loading: ${seedingProgress.deals} deals seeded. Full sync: ${syncedCount}/${ALL_EXPORTS.length} exports.`;
+        }
+        else if (seedingStatus === "completed" && seedingProgress) {
+            message = `Preview ready! ${seedingProgress.deals} deals, ${seedingProgress.contacts} contacts, ${seedingProgress.companies} companies available. Full sync: ${syncedCount}/${ALL_EXPORTS.length} exports.`;
+        }
+        const result = {
+            status: seedingStatus === "in_progress" ? "seeding" : "syncing",
+            syncProgress: `${syncedCount}/${ALL_EXPORTS.length} exports synced`,
+            exportDetails,
+            hasToken,
+            message,
+        };
+        if (seedingStatus) {
+            result.seedingStatus = seedingStatus;
+        }
+        if (seedingProgress) {
+            result.seedingProgress = seedingProgress;
+        }
+        if (seedingError) {
+            result.seedingError = seedingError;
+        }
+        return JSON.stringify(result);
+    }
+    if (initState.status === "error") {
+        const syncedCount = getSyncedCount(initState);
+        const exportDetails = {};
+        for (const name of ALL_EXPORTS) {
+            const exp = initState.exports[name];
+            exportDetails[name] = {
+                status: exp.status,
+                ...(exp.error && { error: exp.error }),
+            };
+        }
+        return JSON.stringify({
+            status: "error",
+            syncProgress: `${syncedCount}/${ALL_EXPORTS.length} exports synced`,
+            exportDetails,
+            hasToken,
+            error: initState.error,
+            message: `Initialization failed: ${initState.error}. Use forceReinit=true to retry.`,
+        });
+    }
+    const exists = await dbExists();
+    const healthy = exists ? await isDbHealthy() : false;
+    if (!exists || !healthy) {
+        return JSON.stringify({
+            status: "error",
+            hasToken,
+            error: "Database file missing or corrupted",
+            message: "Database file issue detected. Use forceReinit=true to reinitialize.",
+        });
+    }
+    const [contacts, companies, deals] = await Promise.all([
+        getRecordCount("contacts"),
+        getRecordCount("companies"),
+        getRecordCount("deals"),
+    ]);
+    const metadata = await getAllMetadata();
+    const result = {
+        status: "ready",
+        syncProgress: "6/6 exports synced",
+        hasToken,
+        lastSynced: metadata.last_synced || null,
+        initializedAt: metadata.initialized_at || initState.startedAt || null,
+        recordCounts: {
+            contacts,
+            companies,
+            deals,
+            contact_company: parseInt(metadata.contact_company_count || "0"),
+            deal_contact: parseInt(metadata.deal_contact_count || "0"),
+            deal_company: parseInt(metadata.deal_company_count || "0"),
+        },
+    };
+    if (initState.seedingStatus) {
+        result.seedingStatus = initState.seedingStatus;
+    }
+    if (initState.seedingProgress) {
+        result.seedingProgress = initState.seedingProgress;
+    }
+    return JSON.stringify(result);
+}

package/dist/tools/query.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const rawSqlSchema: z.ZodObject<{
+    sql: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare function getRawSql(args: z.infer<typeof rawSqlSchema>): Promise<string>;

package/dist/tools/query.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import { executeQuery, isDbHealthy } from "../db/sqlite.js";
+const MAX_ROWS = 1000;
+const QUERY_TIMEOUT_MS = 30_000;
+export const rawSqlSchema = z.object({
+    sql: z.string().min(1).describe("SQL query to execute (SELECT only)"),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(MAX_ROWS)
+        .optional()
+        .describe(`Max rows to return (default: ${MAX_ROWS}, max: ${MAX_ROWS})`),
+});
+function withTimeout(promise, ms) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`Query timed out after ${ms}ms`)), ms)),
+    ]);
+}
+function enforceLimitClause(sql, maxRows) {
+    const normalized = sql.trim();
+    const limitRegex = /\bLIMIT\s+(\d+)/i;
+    const match = normalized.match(limitRegex);
+    if (match) {
+        const existingLimit = parseInt(match[1], 10);
+        if (existingLimit > maxRows) {
+            return normalized.replace(limitRegex, `LIMIT ${maxRows}`);
+        }
+        return normalized;
+    }
+    const endsWithSemicolon = normalized.endsWith(";");
+    const base = endsWithSemicolon ? normalized.slice(0, -1) : normalized;
+    return `${base} LIMIT ${maxRows}${endsWithSemicolon ? ";" : ""}`;
+}
+export async function getRawSql(args) {
+    const healthy = await isDbHealthy();
+    if (!healthy) {
+        return JSON.stringify({
+            success: false,
+            error: "Database not initialized. Run init_database first.",
+        });
+    }
+    const { sql, limit } = args;
+    const effectiveLimit = Math.min(limit ?? MAX_ROWS, MAX_ROWS);
+    // Security: Only allow SELECT queries
+    const trimmedSql = sql.trim().toLowerCase();
+    if (!trimmedSql.startsWith("select")) {
+        return JSON.stringify({
+            success: false,
+            error: "Only SELECT queries are allowed. This is a read-only interface.",
+        });
+    }
+    // Block dangerous keywords
+    const dangerousKeywords = [
+        "insert",
+        "update",
+        "delete",
+        "drop",
+        "alter",
+        "create",
+        "truncate",
+        "replace",
+        "attach",
+        "detach",
+    ];
+    for (const keyword of dangerousKeywords) {
+        if (trimmedSql.includes(keyword)) {
+            return JSON.stringify({
+                success: false,
+                error: `Query contains forbidden keyword: ${keyword}. Only SELECT queries are allowed.`,
+            });
+        }
+    }
+    const safeSql = enforceLimitClause(sql, effectiveLimit);
+    try {
+        const result = await withTimeout(executeQuery(safeSql), QUERY_TIMEOUT_MS);
+        // Parse properties JSON in results if present
+        const parsedRows = result.rows.map((row) => {
+            const parsed = { ...row };
+            if (typeof parsed.properties === "string") {
+                try {
+                    parsed.properties = JSON.parse(parsed.properties);
+                }
+                catch {
+                    // Keep as string if parsing fails
+                }
+            }
+            return parsed;
+        });
+        const wasLimited = parsedRows.length === effectiveLimit;
+        return JSON.stringify({
+            success: true,
+            columns: result.columns,
+            rowCount: parsedRows.length,
+            rows: parsedRows,
+            ...(wasLimited && {
+                warning: `Results limited to ${effectiveLimit} rows. Use OFFSET for pagination.`,
+            }),
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return JSON.stringify({
+            success: false,
+            error: `SQL execution failed: ${errorMessage}`,
+        });
+    }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "daeda-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for HubSpot CRM data sync",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "daeda-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "bun run --watch src/index.ts",
+    "start": "bun run src/index.ts",
+    "start:node": "node dist/index.js"
+  },
+  "dependencies": {
+    "@libsql/client": "^0.14.0",
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "adm-zip": "^0.5.16",
+    "csv-parse": "^6.1.0",
+    "zod": "^4"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.7",
+    "@types/bun": "latest",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}