daeda-mcp 1.0.0

package/dist/db/sqlite.js

@@ -0,0 +1,280 @@
+import { createClient } from "@libsql/client";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { mkdir, access, unlink } from "fs/promises";
+import { getDbEncryptionKey } from "./keychain.js";
+import { SCHEMA_SQL } from "./schema.js";
+import { resetInitState } from "../sync/init-state.js";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DATA_DIR = join(__dirname, "..", "..", "data");
+const DB_PATH = join(DATA_DIR, "hubspot.db");
+let dbClient = null;
+export function getDbPath() {
+    return DB_PATH;
+}
+export async function dbExists() {
+    try {
+        await access(DB_PATH);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isDbHealthy() {
+    try {
+        const db = await getDb();
+        const result = await db.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='contacts'");
+        return result.rows.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getDb() {
+    if (dbClient)
+        return dbClient;
+    await mkdir(DATA_DIR, { recursive: true });
+    const encryptionKey = await getDbEncryptionKey();
+    dbClient = createClient({
+        url: `file:${DB_PATH}`,
+        encryptionKey,
+    });
+    try {
+        await initializeSchema();
+    }
+    catch (err) {
+        const isKeyMismatch = err instanceof Error &&
+            (err.message.includes("SQLITE_NOTADB") ||
+                err.message.includes("file is not a database"));
+        if (isKeyMismatch) {
+            console.error("[sqlite] Encryption key mismatch detected, resetting all sync state...");
+            dbClient.close();
+            dbClient = null;
+            await unlink(DB_PATH).catch(() => { });
+            resetInitState();
+            dbClient = createClient({
+                url: `file:${DB_PATH}`,
+                encryptionKey,
+            });
+            await initializeSchema();
+            console.error("[sqlite] Database and sync state reset with current encryption key");
+        }
+        else {
+            throw err;
+        }
+    }
+    return dbClient;
+}
+async function initializeSchema() {
+    if (!dbClient)
+        throw new Error("Database not initialized");
+    const statements = SCHEMA_SQL.split(";")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+    for (const statement of statements) {
+        await dbClient.execute(statement);
+    }
+}
+export async function closeDb() {
+    if (dbClient) {
+        dbClient.close();
+        dbClient = null;
+    }
+}
+export async function clearTable(table) {
+    const db = await getDb();
+    await db.execute(`DELETE FROM ${table}`);
+}
+export async function insertContact(id, email, properties) {
+    const db = await getDb();
+    await db.execute({
+        sql: `INSERT OR REPLACE INTO contacts (id, email, last_synced, properties) VALUES (?, ?, ?, ?)`,
+        args: [id, email, new Date().toISOString(), JSON.stringify(properties)],
+    });
+}
+export async function insertCompany(id, domain, properties) {
+    const db = await getDb();
+    await db.execute({
+        sql: `INSERT OR REPLACE INTO companies (id, domain, last_synced, properties) VALUES (?, ?, ?, ?)`,
+        args: [id, domain, new Date().toISOString(), JSON.stringify(properties)],
+    });
+}
+export async function insertDeal(id, dealname, properties) {
+    const db = await getDb();
+    await db.execute({
+        sql: `INSERT OR REPLACE INTO deals (id, dealname, last_synced, properties) VALUES (?, ?, ?, ?)`,
+        args: [id, dealname, new Date().toISOString(), JSON.stringify(properties)],
+    });
+}
+export async function insertAssociation(associationType, fromId, toId) {
+    const db = await getDb();
+    let sql;
+    switch (associationType) {
+        case "contact_company":
+            sql = `INSERT OR IGNORE INTO contact_company (contact_id, company_id) VALUES (?, ?)`;
+            break;
+        case "deal_contact":
+            sql = `INSERT OR IGNORE INTO deal_contact (deal_id, contact_id) VALUES (?, ?)`;
+            break;
+        case "deal_company":
+            sql = `INSERT OR IGNORE INTO deal_company (deal_id, company_id) VALUES (?, ?)`;
+            break;
+    }
+    await db.execute({ sql, args: [fromId, toId] });
+}
+export async function setMetadata(key, value) {
+    const db = await getDb();
+    await db.execute({
+        sql: `INSERT OR REPLACE INTO sync_metadata (key, value) VALUES (?, ?)`,
+        args: [key, value],
+    });
+}
+const BATCH_SIZE = 500;
+export async function batchInsertContacts(rows) {
+    if (rows.length === 0)
+        return;
+    const db = await getDb();
+    const now = new Date().toISOString();
+    await db.execute("BEGIN TRANSACTION");
+    try {
+        for (let i = 0; i < rows.length; i += BATCH_SIZE) {
+            const batch = rows.slice(i, i + BATCH_SIZE);
+            const placeholders = batch.map(() => "(?, ?, ?, ?)").join(", ");
+            const args = batch.flatMap((row) => [
+                row.id,
+                row.email,
+                now,
+                JSON.stringify(row.properties),
+            ]);
+            await db.execute({
+                sql: `INSERT OR REPLACE INTO contacts (id, email, last_synced, properties) VALUES ${placeholders}`,
+                args,
+            });
+        }
+        await db.execute("COMMIT");
+    }
+    catch (e) {
+        await db.execute("ROLLBACK");
+        throw e;
+    }
+}
+export async function batchInsertCompanies(rows) {
+    if (rows.length === 0)
+        return;
+    const db = await getDb();
+    const now = new Date().toISOString();
+    await db.execute("BEGIN TRANSACTION");
+    try {
+        for (let i = 0; i < rows.length; i += BATCH_SIZE) {
+            const batch = rows.slice(i, i + BATCH_SIZE);
+            const placeholders = batch.map(() => "(?, ?, ?, ?)").join(", ");
+            const args = batch.flatMap((row) => [
+                row.id,
+                row.domain,
+                now,
+                JSON.stringify(row.properties),
+            ]);
+            await db.execute({
+                sql: `INSERT OR REPLACE INTO companies (id, domain, last_synced, properties) VALUES ${placeholders}`,
+                args,
+            });
+        }
+        await db.execute("COMMIT");
+    }
+    catch (e) {
+        await db.execute("ROLLBACK");
+        throw e;
+    }
+}
+export async function batchInsertDeals(rows) {
+    if (rows.length === 0)
+        return;
+    const db = await getDb();
+    const now = new Date().toISOString();
+    await db.execute("BEGIN TRANSACTION");
+    try {
+        for (let i = 0; i < rows.length; i += BATCH_SIZE) {
+            const batch = rows.slice(i, i + BATCH_SIZE);
+            const placeholders = batch.map(() => "(?, ?, ?, ?)").join(", ");
+            const args = batch.flatMap((row) => [
+                row.id,
+                row.dealname,
+                now,
+                JSON.stringify(row.properties),
+            ]);
+            await db.execute({
+                sql: `INSERT OR REPLACE INTO deals (id, dealname, last_synced, properties) VALUES ${placeholders}`,
+                args,
+            });
+        }
+        await db.execute("COMMIT");
+    }
+    catch (e) {
+        await db.execute("ROLLBACK");
+        throw e;
+    }
+}
+export async function batchInsertAssociations(associationType, rows) {
+    if (rows.length === 0)
+        return;
+    const db = await getDb();
+    const tableConfig = {
+        contact_company: { table: "contact_company", cols: "contact_id, company_id" },
+        deal_contact: { table: "deal_contact", cols: "deal_id, contact_id" },
+        deal_company: { table: "deal_company", cols: "deal_id, company_id" },
+    };
+    const { table, cols } = tableConfig[associationType];
+    await db.execute("BEGIN TRANSACTION");
+    try {
+        for (let i = 0; i < rows.length; i += BATCH_SIZE) {
+            const batch = rows.slice(i, i + BATCH_SIZE);
+            const placeholders = batch.map(() => "(?, ?)").join(", ");
+            const args = batch.flatMap((row) => [row.fromId, row.toId]);
+            await db.execute({
+                sql: `INSERT OR IGNORE INTO ${table} (${cols}) VALUES ${placeholders}`,
+                args,
+            });
+        }
+        await db.execute("COMMIT");
+    }
+    catch (e) {
+        await db.execute("ROLLBACK");
+        throw e;
+    }
+}
+export async function getMetadata(key) {
+    const db = await getDb();
+    const result = await db.execute({
+        sql: `SELECT value FROM sync_metadata WHERE key = ?`,
+        args: [key],
+    });
+    return result.rows[0]?.value ?? null;
+}
+export async function getAllMetadata() {
+    const db = await getDb();
+    const result = await db.execute(`SELECT key, value FROM sync_metadata`);
+    const metadata = {};
+    for (const row of result.rows) {
+        metadata[row.key] = row.value;
+    }
+    return metadata;
+}
+export async function getRecordCount(objectType) {
+    const db = await getDb();
+    const result = await db.execute(`SELECT COUNT(*) as count FROM ${objectType}`);
+    return result.rows[0]?.count ?? 0;
+}
+export async function executeQuery(sql) {
+    const db = await getDb();
+    const result = await db.execute(sql);
+    const columns = result.columns;
+    const rows = result.rows.map((row) => {
+        const obj = {};
+        columns.forEach((col, idx) => {
+            obj[col] = row[idx];
+        });
+        return obj;
+    });
+    return { columns, rows };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { spawn } from "child_process";
+import { z } from "zod";
+import { dbStatus } from "./tools/auth.js";
+import { resumeIfNeeded } from "./sync/init-manager.js";
+import { getRawSql, rawSqlSchema } from "./tools/query.js";
+import { readInitState } from "./sync/init-state.js";
+function openUrl(url) {
+    const platform = process.platform;
+    let command;
+    let args;
+    switch (platform) {
+        case "darwin":
+            command = "open";
+            args = [url];
+            break;
+        case "win32":
+            command = "cmd";
+            args = ["/c", "start", "", url];
+            break;
+        default:
+            command = "xdg-open";
+            args = [url];
+            break;
+    }
+    spawn(command, args, { detached: true, stdio: "ignore" }).unref();
+}
+const DATABASE_SCHEMA = {
+    tables: {
+        contacts: {
+            description: "HubSpot contacts synced to local database",
+            columns: {
+                id: { type: "TEXT", description: "HubSpot contact ID (primary key)" },
+                email: { type: "TEXT", description: "Contact email address (indexed)" },
+                last_synced: { type: "TEXT", description: "ISO timestamp of last sync" },
+                properties: {
+                    type: "TEXT (JSON)",
+                    description: "All HubSpot contact properties stored as JSON. Use json_extract(properties, '$.fieldname') to query specific fields.",
+                },
+            },
+        },
+        companies: {
+            description: "HubSpot companies synced to local database",
+            columns: {
+                id: { type: "TEXT", description: "HubSpot company ID (primary key)" },
+                domain: { type: "TEXT", description: "Company domain (indexed)" },
+                last_synced: { type: "TEXT", description: "ISO timestamp of last sync" },
+                properties: {
+                    type: "TEXT (JSON)",
+                    description: "All HubSpot company properties stored as JSON. Use json_extract(properties, '$.fieldname') to query specific fields.",
+                },
+            },
+        },
+        deals: {
+            description: "HubSpot deals synced to local database",
+            columns: {
+                id: { type: "TEXT", description: "HubSpot deal ID (primary key)" },
+                dealname: { type: "TEXT", description: "Deal name (indexed)" },
+                last_synced: { type: "TEXT", description: "ISO timestamp of last sync" },
+                properties: {
+                    type: "TEXT (JSON)",
+                    description: "All HubSpot deal properties stored as JSON. Use json_extract(properties, '$.fieldname') to query specific fields.",
+                },
+            },
+        },
+    },
+    associations: {
+        contact_company: {
+            description: "Links contacts to companies (many-to-many)",
+            columns: {
+                contact_id: { type: "TEXT", description: "Foreign key to contacts.id" },
+                company_id: { type: "TEXT", description: "Foreign key to companies.id" },
+            },
+        },
+        deal_contact: {
+            description: "Links deals to contacts (many-to-many)",
+            columns: {
+                deal_id: { type: "TEXT", description: "Foreign key to deals.id" },
+                contact_id: { type: "TEXT", description: "Foreign key to contacts.id" },
+            },
+        },
+        deal_company: {
+            description: "Links deals to companies (many-to-many)",
+            columns: {
+                deal_id: { type: "TEXT", description: "Foreign key to deals.id" },
+                company_id: { type: "TEXT", description: "Foreign key to companies.id" },
+            },
+        },
+    },
+    queryExamples: [
+        {
+            description: "Get all contacts with their email",
+            sql: "SELECT id, email, json_extract(properties, '$.firstname') as firstname FROM contacts LIMIT 10",
+        },
+        {
+            description: "Find contacts at a specific company",
+            sql: "SELECT c.* FROM contacts c JOIN contact_company cc ON c.id = cc.contact_id JOIN companies co ON cc.company_id = co.id WHERE co.domain = 'example.com'",
+        },
+        {
+            description: "Get deals with their associated company names",
+            sql: "SELECT d.dealname, json_extract(co.properties, '$.name') as company_name FROM deals d JOIN deal_company dc ON d.id = dc.deal_id JOIN companies co ON dc.company_id = co.id",
+        },
+    ],
+};
+const server = new McpServer({
+    name: "daeda-mcp",
+    version: "1.0.0",
+});
+server.registerTool("db_status", {
+    description: "Check database initialization status and sync progress. The database auto-initializes on server startup. " +
+        "Returns status: 'not_started' | 'sending_requests' | 'seeding' | 'syncing' | 'ready' | 'error'. " +
+        "During 'seeding', a quick preview of ~1000 recent deals is loaded for immediate use while full sync continues. " +
+        "When syncing, shows progress as 'X/6 exports synced'. " +
+        "Use forceReinit=true to restart initialization from scratch.",
+    inputSchema: z.object({
+        forceReinit: z
+            .boolean()
+            .optional()
+            .describe("Force re-initialization from scratch, discarding current progress"),
+    }),
+}, async (args) => {
+    const { forceReinit = false } = args;
+    const result = await dbStatus(forceReinit);
+    return { content: [{ type: "text", text: result }] };
+});
+server.registerTool("get_raw_sql", {
+    description: "Execute a custom SELECT query against the local CRM database. Only SELECT queries are allowed for security.",
+    inputSchema: z.object({
+        sql: z.string().describe("SQL query to execute (SELECT only)"),
+    }),
+}, async (args) => {
+    const result = await getRawSql(rawSqlSchema.parse(args));
+    return { content: [{ type: "text", text: result }] };
+});
+server.registerResource("database-schema", "hubspot://schema", {
+    title: "HubSpot Database Schema",
+    description: "Complete schema for the local HubSpot CRM database including tables, columns, associations, and example queries. " +
+        "All HubSpot properties are stored as JSON in the 'properties' column - use json_extract() to query them.",
+    mimeType: "application/json",
+}, async (uri) => ({
+    contents: [
+        {
+            uri: uri.href,
+            text: JSON.stringify(DATABASE_SCHEMA, null, 2),
+        },
+    ],
+}));
+// Start server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Daeda MCP server started");
+    const state = readInitState();
+    if (state.status === "idle") {
+        openUrl("https://www.daeda.tech/daeda-mcp-waitlist");
+    }
+    try {
+        await resumeIfNeeded();
+    }
+    catch (err) {
+        console.error("Failed to start/resume initialization:", err);
+    }
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/dist/sync/csv-loader.d.ts

@@ -0,0 +1,15 @@
+import { type ObjectType, type AssociationType } from "../db/schema.js";
+export declare function loadContactsCsvFromFile(filePath: string, onProgress?: (loaded: number) => void): Promise<number>;
+export declare function loadCompaniesCsvFromFile(filePath: string, onProgress?: (loaded: number) => void): Promise<number>;
+export declare function loadDealsCsvFromFile(filePath: string, onProgress?: (loaded: number) => void): Promise<number>;
+export declare function loadAssociationsCsvFromFile(filePath: string, associationType: AssociationType, onProgress?: (loaded: number) => void): Promise<number>;
+export declare function loadContactsCsv(csvData: string, onProgress?: (loaded: number) => void): Promise<number>;
+export declare function loadCompaniesCsv(csvData: string, onProgress?: (loaded: number) => void): Promise<number>;
+export declare function loadDealsCsv(csvData: string, onProgress?: (loaded: number) => void): Promise<number>;
+export declare function loadAssociationsCsv(csvData: string, associationType: AssociationType, onProgress?: (loaded: number) => void): Promise<number>;
+export declare function loadAllData(objects: Record<ObjectType, string>, associations: Record<AssociationType, string>, onProgress?: (message: string) => void): Promise<{
+    contacts: number;
+    companies: number;
+    deals: number;
+    associations: Record<AssociationType, number>;
+}>;