daeda-mcp 1.0.0

package/dist/sync/export-api.js

@@ -0,0 +1,355 @@
+import AdmZip from "adm-zip";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, createWriteStream, unlinkSync, } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const HUBSPOT_API_BASE = "https://api.hubapi.com";
+const CACHE_DIR = join(__dirname, "../../data/cache");
+function ensureCacheDir() {
+    if (!existsSync(CACHE_DIR)) {
+        mkdirSync(CACHE_DIR, { recursive: true });
+    }
+}
+function getCachePath(name) {
+    return join(CACHE_DIR, `${name}.csv`);
+}
+export function getCachedCsv(name) {
+    const path = getCachePath(name);
+    if (existsSync(path)) {
+        return readFileSync(path, "utf-8");
+    }
+    return null;
+}
+export function saveCachedCsv(name, data) {
+    ensureCacheDir();
+    writeFileSync(getCachePath(name), data, "utf-8");
+}
+export function hasCachedExports() {
+    const required = ["contacts", "companies", "deals", "contact_company", "deal_contact", "deal_company"];
+    return required.every((name) => existsSync(getCachePath(name)));
+}
+const ASSOCIATION_CONFIGS = [
+    { fromObjectType: "contacts", toObjectType: "companies", associationType: "contact_company" },
+    { fromObjectType: "deals", toObjectType: "contacts", associationType: "deal_contact" },
+    { fromObjectType: "deals", toObjectType: "companies", associationType: "deal_company" },
+];
+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();
+}
+export async function fetchObjectProperties(token, objectType) {
+    const result = (await apiRequest(token, "GET", `/crm/v3/properties/${objectType}`));
+    return result.results.map((prop) => prop.name);
+}
+export async function startObjectExport(token, objectType, properties) {
+    const body = {
+        exportType: "VIEW",
+        format: "CSV",
+        exportName: `daeda-mcp-${objectType}-export`,
+        objectType: objectType.toUpperCase(),
+        objectProperties: properties,
+        associatedObjectType: null,
+    };
+    const result = (await apiRequest(token, "POST", "/crm/v3/exports/export/async", body));
+    return result.id;
+}
+export async function startAssociationExport(token, fromObjectType, toObjectType) {
+    // For associations, we export the "from" object with its associated object IDs
+    const body = {
+        exportType: "VIEW",
+        format: "CSV",
+        exportName: `daeda-mcp-${fromObjectType}-to-${toObjectType}-associations`,
+        objectType: fromObjectType.toUpperCase(),
+        objectProperties: [], // We only need IDs
+        associatedObjectType: toObjectType.toUpperCase(),
+    };
+    const result = (await apiRequest(token, "POST", "/crm/v3/exports/export/async", body));
+    return result.id;
+}
+export async function getExportStatus(token, exportId) {
+    const result = (await apiRequest(token, "GET", `/crm/v3/exports/export/async/tasks/${exportId}/status`));
+    return result;
+}
+export async function listExportTasks(token) {
+    const allTasks = [];
+    let after;
+    do {
+        const path = after
+            ? `/crm/v3/exports/export/async/tasks?after=${after}`
+            : `/crm/v3/exports/export/async/tasks`;
+        const response = (await apiRequest(token, "GET", path));
+        allTasks.push(...response.results);
+        after = response.paging?.next?.after;
+    } while (after);
+    return allTasks;
+}
+const EXPORT_NAME_MAP = {
+    "daeda-mcp-contacts-export": "contacts",
+    "daeda-mcp-companies-export": "companies",
+    "daeda-mcp-deals-export": "deals",
+    "daeda-mcp-contacts-to-companies-associations": "contact_company",
+    "daeda-mcp-deals-to-contacts-associations": "deal_contact",
+    "daeda-mcp-deals-to-companies-associations": "deal_company",
+};
+const REUSABLE_STATUSES = new Set(["COMPLETE", "PENDING", "PROCESSING"]);
+export async function findReusableExports(token, maxAgeDays = 7) {
+    const tasks = await listExportTasks(token);
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);
+    const reusable = new Map();
+    for (const task of tasks) {
+        if (!REUSABLE_STATUSES.has(task.status))
+            continue;
+        const internalName = EXPORT_NAME_MAP[task.exportName];
+        if (!internalName)
+            continue;
+        const createdAt = new Date(task.createdAt);
+        if (createdAt < cutoffDate)
+            continue;
+        const existing = reusable.get(internalName);
+        if (!existing || createdAt > existing.createdAt) {
+            reusable.set(internalName, {
+                exportName: internalName,
+                exportId: task.id,
+                createdAt,
+            });
+        }
+    }
+    return reusable;
+}
+export async function pollExportUntilComplete(token, exportId, onProgress, maxWaitMs = 300000, // 5 minutes
+pollIntervalMs = 2000) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < maxWaitMs) {
+        const status = await getExportStatus(token, exportId);
+        onProgress?.(status.status);
+        if (status.status === "COMPLETE") {
+            if (!status.result) {
+                throw new Error("Export completed but no result URL provided");
+            }
+            return status.result;
+        }
+        if (status.status === "FAILED") {
+            throw new Error(`Export failed: ${status.message || "Unknown error"}`);
+        }
+        // Wait before next poll
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+    throw new Error(`Export timed out after ${maxWaitMs / 1000} seconds`);
+}
+export async function downloadExportCsv(token, downloadUrl) {
+    const response = await fetch(downloadUrl, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to download export: ${response.status}`);
+    }
+    const buffer = await response.arrayBuffer();
+    const data = Buffer.from(buffer);
+    // Check if it's a ZIP file (starts with PK)
+    if (data[0] === 0x50 && data[1] === 0x4b) {
+        const zip = new AdmZip(data);
+        const entries = zip.getEntries();
+        const csvEntries = entries
+            .filter((e) => e.entryName.endsWith(".csv"))
+            .sort((a, b) => a.entryName.localeCompare(b.entryName));
+        if (csvEntries.length === 0) {
+            throw new Error("No CSV file found in ZIP archive");
+        }
+        if (csvEntries.length === 1) {
+            return csvEntries[0].getData().toString("utf-8");
+        }
+        // Multiple CSVs - concatenate them, keeping header only from first file
+        const csvParts = [];
+        for (let i = 0; i < csvEntries.length; i++) {
+            const csvContent = csvEntries[i].getData().toString("utf-8");
+            if (i === 0) {
+                csvParts.push(csvContent);
+            }
+            else {
+                // Skip header row for subsequent files
+                const firstNewline = csvContent.indexOf("\n");
+                if (firstNewline !== -1) {
+                    csvParts.push(csvContent.slice(firstNewline + 1));
+                }
+            }
+        }
+        console.error(`[export-api] Concatenated ${csvEntries.length} CSV files from ZIP`);
+        return csvParts.join("\n");
+    }
+    // Not a ZIP, return as text
+    return data.toString("utf-8");
+}
+export async function downloadExportCsvToFile(token, downloadUrl, exportName) {
+    ensureCacheDir();
+    const outputPath = getCachePath(exportName);
+    const tempPath = `${outputPath}.tmp`;
+    const response = await fetch(downloadUrl, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to download export: ${response.status}`);
+    }
+    const contentLength = response.headers.get("content-length");
+    console.error(`[export-api] Downloading ${exportName} (${contentLength ? `${Math.round(Number(contentLength) / 1024 / 1024)}MB` : "unknown size"})...`);
+    if (!response.body) {
+        throw new Error("Response has no body");
+    }
+    await pipeline(Readable.fromWeb(response.body), createWriteStream(tempPath));
+    const data = readFileSync(tempPath);
+    if (data[0] === 0x50 && data[1] === 0x4b) {
+        const zip = new AdmZip(tempPath);
+        const entries = zip.getEntries();
+        const csvEntries = entries
+            .filter((e) => e.entryName.endsWith(".csv"))
+            .sort((a, b) => a.entryName.localeCompare(b.entryName));
+        if (csvEntries.length === 0) {
+            unlinkSync(tempPath);
+            throw new Error("No CSV file found in ZIP archive");
+        }
+        const writeStream = createWriteStream(outputPath);
+        for (let i = 0; i < csvEntries.length; i++) {
+            const csvContent = csvEntries[i].getData().toString("utf-8");
+            if (i === 0) {
+                writeStream.write(csvContent);
+            }
+            else {
+                const firstNewline = csvContent.indexOf("\n");
+                if (firstNewline !== -1) {
+                    writeStream.write("\n");
+                    writeStream.write(csvContent.slice(firstNewline + 1));
+                }
+            }
+        }
+        await new Promise((resolve, reject) => {
+            writeStream.end((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+        unlinkSync(tempPath);
+        console.error(`[export-api] Extracted and concatenated ${csvEntries.length} CSV files from ZIP`);
+    }
+    else {
+        const { renameSync } = await import("node:fs");
+        renameSync(tempPath, outputPath);
+    }
+    return outputPath;
+}
+export async function runAllExports(token, onProgress, useCache = true) {
+    const objectTypes = ["contacts", "companies", "deals"];
+    const objects = {};
+    const associations = {};
+    // Check if we have all cached exports
+    if (useCache && hasCachedExports()) {
+        onProgress?.("Found cached exports, loading from disk...");
+        for (const objectType of objectTypes) {
+            objects[objectType] = getCachedCsv(objectType);
+            onProgress?.(`Loaded ${objectType} from cache`);
+        }
+        for (const config of ASSOCIATION_CONFIGS) {
+            associations[config.associationType] = getCachedCsv(config.associationType);
+            onProgress?.(`Loaded ${config.associationType} from cache`);
+        }
+        return {
+            objects: objects,
+            associations: associations,
+        };
+    }
+    onProgress?.("Starting parallel exports from HubSpot...");
+    const objectExportPromises = objectTypes.map(async (objectType) => {
+        const cached = useCache ? getCachedCsv(objectType) : null;
+        if (cached) {
+            onProgress?.(`Using cached ${objectType} export`);
+            return { objectType, csvData: cached, fromCache: true };
+        }
+        onProgress?.(`[${objectType}] Fetching properties...`);
+        const properties = await fetchObjectProperties(token, objectType);
+        onProgress?.(`[${objectType}] Found ${properties.length} properties, starting export...`);
+        const exportId = await startObjectExport(token, objectType, properties);
+        onProgress?.(`[${objectType}] Export started, polling for completion...`);
+        const downloadUrl = await pollExportUntilComplete(token, exportId, (status) => {
+            onProgress?.(`[${objectType}] ${status}`);
+        });
+        onProgress?.(`[${objectType}] Downloading CSV...`);
+        const csvData = await downloadExportCsv(token, downloadUrl);
+        saveCachedCsv(objectType, csvData);
+        onProgress?.(`[${objectType}] Export complete`);
+        return { objectType, csvData, fromCache: false };
+    });
+    const associationExportPromises = ASSOCIATION_CONFIGS.map(async (config) => {
+        const label = `${config.fromObjectType}→${config.toObjectType}`;
+        const cached = useCache ? getCachedCsv(config.associationType) : null;
+        if (cached) {
+            onProgress?.(`Using cached ${label} association export`);
+            return { associationType: config.associationType, csvData: cached, fromCache: true };
+        }
+        onProgress?.(`[${label}] Starting association export...`);
+        const exportId = await startAssociationExport(token, config.fromObjectType, config.toObjectType);
+        onProgress?.(`[${label}] Export started, polling for completion...`);
+        const downloadUrl = await pollExportUntilComplete(token, exportId, (status) => {
+            onProgress?.(`[${label}] ${status}`);
+        });
+        onProgress?.(`[${label}] Downloading CSV...`);
+        const csvData = await downloadExportCsv(token, downloadUrl);
+        saveCachedCsv(config.associationType, csvData);
+        onProgress?.(`[${label}] Export complete`);
+        return { associationType: config.associationType, csvData, fromCache: false };
+    });
+    const [objectResults, associationResults] = await Promise.all([
+        Promise.all(objectExportPromises),
+        Promise.all(associationExportPromises),
+    ]);
+    for (const result of objectResults) {
+        objects[result.objectType] = result.csvData;
+    }
+    for (const result of associationResults) {
+        associations[result.associationType] = result.csvData;
+    }
+    onProgress?.("All exports complete");
+    return {
+        objects: objects,
+        associations: associations,
+    };
+}
+export async function validateToken(token) {
+    try {
+        const response = await fetch(`${HUBSPOT_API_BASE}/crm/v3/objects/contacts?limit=1`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        if (response.ok) {
+            return { valid: true };
+        }
+        const errorText = await response.text();
+        return {
+            valid: false,
+            error: `HTTP ${response.status}: ${errorText}`
+        };
+    }
+    catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        return { valid: false, error: errorMessage };
+    }
+}
+export { ASSOCIATION_CONFIGS };

package/dist/sync/init-manager.d.ts

@@ -0,0 +1,5 @@
+import { type InitState } from "./init-state.js";
+export declare function getInitStatus(): InitState;
+export declare function startInitialization(force?: boolean): Promise<void>;
+export declare function resumeIfNeeded(): Promise<void>;
+export declare function forceReinitialize(): void;

package/dist/sync/init-manager.js

@@ -0,0 +1,274 @@
+import { readInitState, writeInitState, createInitialState, isFullySynced, getSyncedCount, ALL_EXPORTS, } from "./init-state.js";
+import { validateToken, startObjectExport, startAssociationExport, getExportStatus, downloadExportCsvToFile, fetchObjectProperties, findReusableExports, } from "./export-api.js";
+import { loadContactsCsvFromFile, loadCompaniesCsvFromFile, loadDealsCsvFromFile, loadAssociationsCsvFromFile, } from "./csv-loader.js";
+import { runSeeding } from "./seeder.js";
+import { getHubSpotToken } from "../db/keychain.js";
+import { getDb, setMetadata } from "../db/sqlite.js";
+const POLL_INTERVAL_MS = 3000;
+const OBJECT_EXPORTS = ["contacts", "companies", "deals"];
+const ASSOCIATION_EXPORTS = [
+    { name: "contact_company", from: "contacts", to: "companies" },
+    { name: "deal_contact", from: "deals", to: "contacts" },
+    { name: "deal_company", from: "deals", to: "companies" },
+];
+let pollLoopRunning = false;
+let pollLoopTimeout = null;
+export function getInitStatus() {
+    return readInitState();
+}
+export async function startInitialization(force = false) {
+    const state = readInitState();
+    if (state.status === "ready" && !force) {
+        console.error("[init-manager] Database already initialized");
+        return;
+    }
+    if (state.status === "polling_exports" && !force) {
+        console.error("[init-manager] Initialization already in progress, resuming poll loop");
+        startPollLoop();
+        return;
+    }
+    if (state.status === "sending_requests" && !force) {
+        console.error("[init-manager] Export requests in progress");
+        return;
+    }
+    const token = getHubSpotToken();
+    if (!token) {
+        const errorState = createInitialState();
+        errorState.status = "error";
+        errorState.error = "No HubSpot token found. Set HS_PRIVATE_TOKEN environment variable.";
+        writeInitState(errorState);
+        console.error("[init-manager] No HubSpot token");
+        return;
+    }
+    const validation = await validateToken(token);
+    if (!validation.valid) {
+        const errorState = createInitialState();
+        errorState.status = "error";
+        errorState.error = `Invalid HubSpot token: ${validation.error}`;
+        writeInitState(errorState);
+        console.error("[init-manager] Invalid token:", validation.error);
+        return;
+    }
+    await getDb();
+    const newState = createInitialState();
+    newState.status = "sending_requests";
+    newState.startedAt = new Date().toISOString();
+    writeInitState(newState);
+    console.error("[init-manager] Starting export requests...");
+    try {
+        await fireAllExportRequests(token, newState);
+        newState.status = "polling_exports";
+        newState.seedingStatus = "pending";
+        writeInitState(newState);
+        console.error("[init-manager] All export requests sent, starting seeding and poll loop");
+        runSeeding(token).catch((err) => {
+            console.error("[init-manager] Seeding failed (non-fatal):", err);
+        });
+        startPollLoop();
+    }
+    catch (err) {
+        newState.status = "error";
+        newState.error = err instanceof Error ? err.message : String(err);
+        writeInitState(newState);
+        console.error("[init-manager] Failed to send export requests:", newState.error);
+    }
+}
+async function fireAllExportRequests(token, state) {
+    console.error("[init-manager] Checking for reusable exports from the past week...");
+    let reusableExports;
+    try {
+        reusableExports = await findReusableExports(token, 7);
+        if (reusableExports.size > 0) {
+            console.error(`[init-manager] Found ${reusableExports.size} reusable export(s)`);
+        }
+    }
+    catch (err) {
+        console.error("[init-manager] Failed to check for reusable exports, creating new ones:", err);
+        reusableExports = new Map();
+    }
+    for (const objectType of OBJECT_EXPORTS) {
+        const existing = reusableExports.get(objectType);
+        if (existing) {
+            state.exports[objectType].exportId = existing.exportId;
+            state.exports[objectType].status = "polling";
+            writeInitState(state);
+            console.error(`[init-manager] Reusing ${objectType} export: ${existing.exportId} (created ${existing.createdAt.toISOString()})`);
+            continue;
+        }
+        const properties = await fetchObjectProperties(token, objectType);
+        const exportId = await startObjectExport(token, objectType, properties);
+        state.exports[objectType].exportId = exportId;
+        state.exports[objectType].status = "polling";
+        writeInitState(state);
+        console.error(`[init-manager] Started new ${objectType} export: ${exportId}`);
+    }
+    for (const assoc of ASSOCIATION_EXPORTS) {
+        const existing = reusableExports.get(assoc.name);
+        if (existing) {
+            state.exports[assoc.name].exportId = existing.exportId;
+            state.exports[assoc.name].status = "polling";
+            writeInitState(state);
+            console.error(`[init-manager] Reusing ${assoc.name} export: ${existing.exportId} (created ${existing.createdAt.toISOString()})`);
+            continue;
+        }
+        const exportId = await startAssociationExport(token, assoc.from, assoc.to);
+        state.exports[assoc.name].exportId = exportId;
+        state.exports[assoc.name].status = "polling";
+        writeInitState(state);
+        console.error(`[init-manager] Started new ${assoc.name} export: ${exportId}`);
+    }
+}
+function startPollLoop() {
+    if (pollLoopRunning) {
+        return;
+    }
+    pollLoopRunning = true;
+    schedulePoll();
+}
+function stopPollLoop() {
+    pollLoopRunning = false;
+    if (pollLoopTimeout) {
+        clearTimeout(pollLoopTimeout);
+        pollLoopTimeout = null;
+    }
+}
+function schedulePoll() {
+    if (!pollLoopRunning)
+        return;
+    pollLoopTimeout = setTimeout(() => {
+        pollOnce().catch((err) => {
+            console.error("[init-manager] Poll error:", err);
+        });
+    }, POLL_INTERVAL_MS);
+}
+async function pollOnce() {
+    const state = readInitState();
+    if (state.status !== "polling_exports") {
+        stopPollLoop();
+        return;
+    }
+    const token = getHubSpotToken();
+    if (!token) {
+        state.status = "error";
+        state.error = "Token no longer available";
+        writeInitState(state);
+        stopPollLoop();
+        return;
+    }
+    let anyPolling = false;
+    for (const exportName of ALL_EXPORTS) {
+        const exportState = state.exports[exportName];
+        if (exportState.status !== "polling" || !exportState.exportId) {
+            continue;
+        }
+        anyPolling = true;
+        try {
+            const status = await getExportStatus(token, exportState.exportId);
+            if (status.status === "COMPLETE" && status.result) {
+                console.error(`[init-manager] ${exportName} export complete, downloading...`);
+                const filePath = await downloadExportCsvToFile(token, status.result, exportName);
+                console.error(`[init-manager] ${exportName} syncing to database (streaming)...`);
+                await syncExportToDb(exportName, filePath);
+                exportState.status = "synced";
+                writeInitState(state);
+                console.error(`[init-manager] ${exportName} synced successfully`);
+            }
+            else if (status.status === "FAILED") {
+                exportState.status = "error";
+                exportState.error = status.message || "Export failed";
+                writeInitState(state);
+                console.error(`[init-manager] ${exportName} export failed:`, status.message);
+            }
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            console.error(`[init-manager] Error polling ${exportName}:`, errMsg);
+        }
+    }
+    if (isFullySynced(state)) {
+        state.status = "ready";
+        await setMetadata("last_synced", new Date().toISOString());
+        await setMetadata("initialized_at", state.startedAt || new Date().toISOString());
+        writeInitState(state);
+        stopPollLoop();
+        console.error("[init-manager] All exports synced, database ready");
+        return;
+    }
+    const hasErrors = ALL_EXPORTS.some((name) => state.exports[name].status === "error");
+    if (hasErrors && !anyPolling) {
+        state.status = "error";
+        state.error = "One or more exports failed";
+        writeInitState(state);
+        stopPollLoop();
+        console.error("[init-manager] Initialization failed due to export errors");
+        return;
+    }
+    schedulePoll();
+}
+async function syncExportToDb(exportName, filePath) {
+    switch (exportName) {
+        case "contacts": {
+            const count = await loadContactsCsvFromFile(filePath);
+            await setMetadata("contacts_count", String(count));
+            break;
+        }
+        case "companies": {
+            const count = await loadCompaniesCsvFromFile(filePath);
+            await setMetadata("companies_count", String(count));
+            break;
+        }
+        case "deals": {
+            const count = await loadDealsCsvFromFile(filePath);
+            await setMetadata("deals_count", String(count));
+            break;
+        }
+        case "contact_company":
+        case "deal_contact":
+        case "deal_company": {
+            const count = await loadAssociationsCsvFromFile(filePath, exportName);
+            await setMetadata(`${exportName}_count`, String(count));
+            break;
+        }
+    }
+}
+export async function resumeIfNeeded() {
+    const state = readInitState();
+    if (state.status === "polling_exports") {
+        console.error("[init-manager] Resuming poll loop from previous state");
+        const syncedCount = getSyncedCount(state);
+        const seedingIncomplete = !state.seedingStatus ||
+            state.seedingStatus === "pending" ||
+            state.seedingStatus === "error";
+        if (syncedCount === 0 && seedingIncomplete) {
+            const token = getHubSpotToken();
+            if (token) {
+                console.error("[init-manager] No data yet, re-running quick seed");
+                runSeeding(token).catch((err) => {
+                    console.error("[init-manager] Seeding failed (non-fatal):", err);
+                });
+            }
+        }
+        startPollLoop();
+        return;
+    }
+    if (state.status === "sending_requests") {
+        console.error("[init-manager] Previous init was interrupted during request phase, restarting");
+        await startInitialization(true);
+        return;
+    }
+    if (state.status === "idle" || state.status === "error") {
+        console.error("[init-manager] Starting fresh initialization");
+        await startInitialization(false);
+        return;
+    }
+    if (state.status === "ready") {
+        console.error("[init-manager] Database already initialized");
+        return;
+    }
+}
+export function forceReinitialize() {
+    stopPollLoop();
+    startInitialization(true).catch((err) => {
+        console.error("[init-manager] Force reinit failed:", err);
+    });
+}

package/dist/sync/init-state.d.ts

@@ -0,0 +1,31 @@
+export type ExportName = "contacts" | "companies" | "deals" | "contact_company" | "deal_contact" | "deal_company";
+export declare const ALL_EXPORTS: ExportName[];
+export type ExportStatus = "pending" | "polling" | "synced" | "error";
+export type SeedingStatus = "pending" | "in_progress" | "completed" | "skipped" | "error";
+export interface SeedingProgress {
+    deals: number;
+    contacts: number;
+    companies: number;
+}
+export interface ExportState {
+    exportId: string | null;
+    status: ExportStatus;
+    error: string | null;
+}
+export type InitStatus = "idle" | "sending_requests" | "polling_exports" | "ready" | "error";
+export interface InitState {
+    status: InitStatus;
+    exports: Record<ExportName, ExportState>;
+    startedAt: string | null;
+    error: string | null;
+    seedingStatus?: SeedingStatus;
+    seedingProgress?: SeedingProgress;
+    seedingError?: string;
+}
+export declare function createInitialState(): InitState;
+export declare function readInitState(): InitState;
+export declare function writeInitState(state: InitState): void;
+export declare function resetInitState(): void;
+export declare function getSyncedCount(state: InitState): number;
+export declare function isFullySynced(state: InitState): boolean;
+export declare function getStateFilePath(): string;