newo 3.0.0 → 3.2.0

package/dist/sync/attributes.js

@@ -1,8 +1,10 @@
 /**
- * Customer attributes synchronization module
+ * Customer and project attributes synchronization module
  */
-import { getCustomerAttributes } from '../api.js';
+import { getCustomerAttributes, getProjectAttributes, listProjects, updateProjectAttribute } from '../api.js';
 import { writeFileSafe, customerAttributesPath, customerAttributesMapPath, customerAttributesBackupPath } from '../fsutil.js';
+import path from 'path';
+import fs from 'fs-extra';
 import yaml from 'js-yaml';
 /**
  * Save customer attributes to YAML format and return content for hashing
@@ -87,4 +89,221 @@ export async function saveCustomerAttributes(client, customer, verbose = false)
         throw error;
     }
 }
+/**
+ * Save project attributes to YAML format in project directory
+ */
+export async function saveProjectAttributes(client, customer, projectId, projectIdn, verbose = false) {
+    if (verbose)
+        console.log(`   🔍 Fetching project attributes for ${projectIdn}...`);
+    try {
+        const response = await getProjectAttributes(client, projectId, true); // Include hidden attributes
+        // API returns { groups: [...], attributes: [...] }
+        const attributes = response.attributes || response;
+        if (verbose)
+            console.log(`   📦 Found ${Array.isArray(attributes) ? attributes.length : 0} project attributes`);
+        if (!Array.isArray(attributes) || attributes.length === 0) {
+            if (verbose)
+                console.log(`   ℹ No project attributes found for ${projectIdn}`);
+            return;
+        }
+        // Create ID mapping for push operations
+        const idMapping = {};
+        // Transform attributes to match format (no ID fields)
+        const cleanAttributes = attributes.map(attr => {
+            // Store ID mapping
+            if (attr.id) {
+                idMapping[attr.idn] = attr.id;
+            }
+            // Special handling for complex JSON string values
+            let processedValue = attr.value;
+            if (typeof attr.value === 'string' && attr.value.startsWith('[{') && attr.value.endsWith('}]')) {
+                try {
+                    const parsed = JSON.parse(attr.value);
+                    processedValue = JSON.stringify(parsed, null, 0);
+                }
+                catch (e) {
+                    processedValue = attr.value;
+                }
+            }
+            return {
+                idn: attr.idn,
+                value: processedValue,
+                title: attr.title || "",
+                description: attr.description || "",
+                group: attr.group || "",
+                is_hidden: attr.is_hidden,
+                possible_values: attr.possible_values || [],
+                value_type: `__ENUM_PLACEHOLDER_${attr.value_type}__`
+            };
+        });
+        const attributesYaml = {
+            attributes: cleanAttributes
+        };
+        // Configure YAML output
+        let yamlContent = yaml.dump(attributesYaml, {
+            indent: 2,
+            quotingType: '"',
+            forceQuotes: false,
+            lineWidth: 80,
+            noRefs: true,
+            sortKeys: false,
+            flowLevel: -1
+        });
+        // Post-process to fix enum format
+        yamlContent = yamlContent.replace(/__ENUM_PLACEHOLDER_(\w+)__/g, '!enum "AttributeValueTypes.$1"');
+        yamlContent = yamlContent.replace(/\\"/g, '"');
+        // Save to project directory
+        const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+        const projectDir = path.join(customerDir, 'projects', projectIdn);
+        await fs.ensureDir(projectDir);
+        const attributesFile = path.join(projectDir, 'attributes.yaml');
+        const attributesMapFile = path.join(customerDir, '.newo', customer.idn, `project_${projectIdn}_attributes-map.json`);
+        await writeFileSafe(attributesFile, yamlContent);
+        await fs.ensureDir(path.dirname(attributesMapFile));
+        await writeFileSafe(attributesMapFile, JSON.stringify(idMapping, null, 2));
+        if (verbose) {
+            console.log(`   ✓ Saved project attributes to projects/${projectIdn}/attributes.yaml`);
+            console.log(`   ✓ Saved attribute ID mapping`);
+        }
+    }
+    catch (error) {
+        if (verbose)
+            console.error(`   ❌ Failed to fetch project attributes for ${projectIdn}:`, error.message);
+    }
+}
+/**
+ * Pull all project attributes for a customer
+ */
+export async function pullAllProjectAttributes(client, customer, verbose = false) {
+    if (verbose)
+        console.log(`\n📋 Fetching project attributes...`);
+    try {
+        // Get all projects for this customer
+        const projects = await listProjects(client);
+        if (verbose)
+            console.log(`✓ Found ${projects.length} projects\n`);
+        for (const project of projects) {
+            await saveProjectAttributes(client, customer, project.id, project.idn, verbose);
+        }
+        if (verbose)
+            console.log(`\n✅ Completed project attributes sync for ${projects.length} projects\n`);
+    }
+    catch (error) {
+        console.error(`❌ Failed to pull project attributes:`, error);
+        throw error;
+    }
+}
+/**
+ * Push modified project attributes for a specific project
+ */
+export async function pushProjectAttributes(client, customer, projectId, projectIdn, verbose = false) {
+    const customerDir = path.join(process.cwd(), 'newo_customers', customer.idn);
+    const attributesFile = path.join(customerDir, 'projects', projectIdn, 'attributes.yaml');
+    const attributesMapFile = path.join(customerDir, '.newo', customer.idn, `project_${projectIdn}_attributes-map.json`);
+    // Check if attributes file exists
+    if (!await fs.pathExists(attributesFile)) {
+        if (verbose)
+            console.log(`   ℹ No project attributes file for ${projectIdn}`);
+        return 0;
+    }
+    // Load local attributes
+    // Read as text and replace the custom !enum tags before parsing
+    let attributesContent = await fs.readFile(attributesFile, 'utf-8');
+    // Replace custom enum tags with the actual value
+    attributesContent = attributesContent.replace(/!enum "AttributeValueTypes\.(\w+)"/g, '$1');
+    const localData = yaml.load(attributesContent);
+    const localAttributes = localData.attributes || [];
+    // Load ID mapping
+    if (!await fs.pathExists(attributesMapFile)) {
+        if (verbose)
+            console.log(`   ⚠ No ID mapping found for project ${projectIdn}, skipping push`);
+        return 0;
+    }
+    const idMapping = JSON.parse(await fs.readFile(attributesMapFile, 'utf-8'));
+    // Fetch current remote attributes for comparison
+    const remoteResponse = await getProjectAttributes(client, projectId, true);
+    const remoteAttributes = remoteResponse.attributes || [];
+    // Create map of remote attributes by IDN
+    const remoteMap = new Map();
+    remoteAttributes.forEach(attr => remoteMap.set(attr.idn, attr));
+    let updatedCount = 0;
+    // Check each local attribute for changes
+    for (const localAttr of localAttributes) {
+        const attributeId = idMapping[localAttr.idn];
+        if (!attributeId) {
+            if (verbose)
+                console.log(`   ⚠ No ID mapping for attribute ${localAttr.idn}, skipping`);
+            continue;
+        }
+        const remoteAttr = remoteMap.get(localAttr.idn);
+        if (!remoteAttr) {
+            if (verbose)
+                console.log(`   ⚠ Attribute ${localAttr.idn} not found remotely, skipping`);
+            continue;
+        }
+        // Value type is already parsed (we removed !enum tags above)
+        const valueType = localAttr.value_type;
+        // Check if value changed
+        const localValue = String(localAttr.value || '');
+        const remoteValue = String(remoteAttr.value || '');
+        if (localValue !== remoteValue) {
+            if (verbose)
+                console.log(`   🔄 Updating project attribute: ${localAttr.idn}`);
+            try {
+                const attributeToUpdate = {
+                    id: attributeId,
+                    idn: localAttr.idn,
+                    value: localAttr.value,
+                    title: localAttr.title,
+                    description: localAttr.description,
+                    group: localAttr.group,
+                    is_hidden: localAttr.is_hidden,
+                    possible_values: localAttr.possible_values,
+                    value_type: valueType
+                };
+                await updateProjectAttribute(client, projectId, attributeToUpdate);
+                if (verbose)
+                    console.log(`   ✅ Updated: ${localAttr.idn} (${localAttr.title})`);
+                updatedCount++;
+            }
+            catch (error) {
+                const errorDetail = error.response?.data || error.message;
+                console.error(`   ❌ Failed to update ${localAttr.idn}: ${JSON.stringify(errorDetail)}`);
+                if (verbose) {
+                    console.error(`      API response:`, error.response?.status, error.response?.statusText);
+                    console.error(`      Endpoint tried: PUT /api/v1/project/attributes/${attributeId}`);
+                }
+            }
+        }
+        else if (verbose) {
+            console.log(`   ✓ No changes: ${localAttr.idn}`);
+        }
+    }
+    return updatedCount;
+}
+/**
+ * Push all modified project attributes for all projects
+ */
+export async function pushAllProjectAttributes(client, customer, projectsMap, verbose = false) {
+    if (verbose)
+        console.log(`\n📋 Checking project attributes for changes...`);
+    let totalUpdated = 0;
+    for (const [projectIdn, projectInfo] of Object.entries(projectsMap)) {
+        if (!projectIdn)
+            continue; // Skip empty project idn (legacy format)
+        if (verbose)
+            console.log(`\n  📁 Project: ${projectIdn}`);
+        const updated = await pushProjectAttributes(client, customer, projectInfo.projectId, projectInfo.projectIdn || projectIdn, verbose);
+        totalUpdated += updated;
+    }
+    // Always show summary if changes were made
+    if (totalUpdated > 0) {
+        console.log(`\n✅ Updated ${totalUpdated} project attribute(s)`);
+    }
+    else {
+        if (verbose)
+            console.log(`\n✓ No project attribute changes to push`);
+    }
+    return totalUpdated;
+}
 //# sourceMappingURL=attributes.js.map

package/dist/sync/integrations.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Integration and connector synchronization module
+ * Handles pull/push of integrations and connectors to/from NEWO platform
+ */
+import type { AxiosInstance } from 'axios';
+import type { IntegrationMetadata, ConnectorMetadata } from '../types.js';
+/**
+ * Pull all integrations and connectors from NEWO platform
+ */
+export declare function pullIntegrations(client: AxiosInstance, customerDir: string, verbose?: boolean): Promise<void>;
+/**
+ * Push integration changes from local files to NEWO platform
+ */
+export declare function pushIntegrations(client: AxiosInstance, customerDir: string, verbose?: boolean): Promise<void>;
+/**
+ * List all local integrations from file system
+ */
+export declare function listLocalIntegrations(customerDir: string): Promise<IntegrationMetadata[]>;
+/**
+ * Get connector details from local file
+ */
+export declare function getLocalConnector(customerDir: string, integrationIdn: string, connectorIdn: string): Promise<ConnectorMetadata | null>;
+//# sourceMappingURL=integrations.d.ts.map

package/dist/sync/integrations.js

@@ -0,0 +1,340 @@
+/**
+ * Integration and connector synchronization module
+ * Handles pull/push of integrations and connectors to/from NEWO platform
+ */
+import path from 'path';
+import fs from 'fs-extra';
+import yaml from 'js-yaml';
+import { listIntegrations, listConnectors, getIntegrationSettings, createConnector, updateConnector, deleteConnector, listOutgoingWebhooks, listIncomingWebhooks } from '../api.js';
+/**
+ * Pull all integrations and connectors from NEWO platform
+ */
+export async function pullIntegrations(client, customerDir, verbose = false) {
+    if (verbose)
+        console.log('\n📦 Pulling integrations from NEWO platform...\n');
+    // Create integrations directory
+    const integrationsDir = path.join(customerDir, 'integrations');
+    await fs.ensureDir(integrationsDir);
+    // Fetch all integrations
+    const integrations = await listIntegrations(client);
+    if (verbose)
+        console.log(`✓ Found ${integrations.length} integrations`);
+    const integrationsMetadata = [];
+    // Process each integration
+    for (const integration of integrations) {
+        if (verbose)
+            console.log(`\n  📦 Processing: ${integration.title} (${integration.idn})`);
+        // Add to metadata list
+        integrationsMetadata.push({
+            id: integration.id,
+            idn: integration.idn,
+            title: integration.title,
+            description: integration.description,
+            channel: integration.channel,
+            is_disabled: integration.is_disabled
+        });
+        // Create integration directory
+        const integrationDir = path.join(integrationsDir, integration.idn);
+        await fs.ensureDir(integrationDir);
+        // Fetch integration settings
+        let integrationSettings = [];
+        try {
+            integrationSettings = await getIntegrationSettings(client, integration.id);
+        }
+        catch (error) {
+            // Settings endpoint may not be available for all integrations
+            if (verbose && error.response?.status !== 404) {
+                console.log(`     ⚠ Could not fetch settings: ${error.message}`);
+            }
+        }
+        // Save combined integration file (metadata + settings)
+        const integrationFile = path.join(integrationDir, `${integration.idn}.yaml`);
+        const integrationData = {
+            id: integration.id,
+            idn: integration.idn,
+            title: integration.title,
+            description: integration.description,
+            channel: integration.channel,
+            is_disabled: integration.is_disabled
+        };
+        // Add settings array if any settings exist
+        if (integrationSettings.length > 0) {
+            integrationData.settings = integrationSettings;
+        }
+        await fs.writeFile(integrationFile, yaml.dump(integrationData, { lineWidth: -1 }));
+        if (verbose)
+            console.log(`     ✓ Saved integration → ${integration.idn}.yaml (${integrationSettings.length} settings)`);
+        // Fetch and save connectors
+        const connectors = await listConnectors(client, integration.id);
+        if (verbose)
+            console.log(`     Connectors: ${connectors.length} found`);
+        if (connectors.length > 0) {
+            const connectorsDir = path.join(integrationDir, 'connectors');
+            await fs.ensureDir(connectorsDir);
+            for (const connector of connectors) {
+                const connectorMetadata = {
+                    id: connector.id,
+                    connector_idn: connector.connector_idn,
+                    title: connector.title,
+                    status: connector.status,
+                    integration_idn: integration.idn,
+                    settings: connector.settings
+                };
+                // Create subdirectory for this connector
+                const connectorDir = path.join(connectorsDir, connector.connector_idn);
+                await fs.ensureDir(connectorDir);
+                // Save connector YAML file inside its subdirectory
+                const connectorFile = path.join(connectorDir, `${connector.connector_idn}.yaml`);
+                await fs.writeFile(connectorFile, yaml.dump(connectorMetadata, { lineWidth: -1 }));
+                if (verbose)
+                    console.log(`     ✓ Saved: ${connector.title} → connectors/${connector.connector_idn}/${connector.connector_idn}.yaml`);
+            }
+        }
+    }
+    // Fetch and save webhooks (for API integration connectors only)
+    if (verbose)
+        console.log(`\n📡 Fetching webhooks...`);
+    try {
+        const outgoingWebhooks = await listOutgoingWebhooks(client);
+        const incomingWebhooks = await listIncomingWebhooks(client);
+        if (verbose)
+            console.log(`✓ Found ${outgoingWebhooks.length} outgoing webhooks`);
+        if (verbose)
+            console.log(`✓ Found ${incomingWebhooks.length} incoming webhooks`);
+        // Group webhooks by connector_idn
+        const outgoingByConnector = new Map();
+        const incomingByConnector = new Map();
+        outgoingWebhooks.forEach(webhook => {
+            if (!outgoingByConnector.has(webhook.connector_idn)) {
+                outgoingByConnector.set(webhook.connector_idn, []);
+            }
+            outgoingByConnector.get(webhook.connector_idn).push(webhook);
+        });
+        incomingWebhooks.forEach(webhook => {
+            if (!incomingByConnector.has(webhook.connector_idn)) {
+                incomingByConnector.set(webhook.connector_idn, []);
+            }
+            incomingByConnector.get(webhook.connector_idn).push(webhook);
+        });
+        // Save webhooks to appropriate connector directories
+        for (const integration of integrations) {
+            const integrationDir = path.join(integrationsDir, integration.idn);
+            const connectorsDir = path.join(integrationDir, 'connectors');
+            if (await fs.pathExists(connectorsDir)) {
+                const connectors = await listConnectors(client, integration.id);
+                for (const connector of connectors) {
+                    const connectorWebhooksDir = path.join(connectorsDir, connector.connector_idn, 'webhooks');
+                    const outgoing = outgoingByConnector.get(connector.connector_idn) || [];
+                    const incoming = incomingByConnector.get(connector.connector_idn) || [];
+                    if (outgoing.length > 0 || incoming.length > 0) {
+                        await fs.ensureDir(connectorWebhooksDir);
+                        if (outgoing.length > 0) {
+                            const outgoingFile = path.join(connectorWebhooksDir, 'outgoing.yaml');
+                            await fs.writeFile(outgoingFile, yaml.dump({ webhooks: outgoing }, { lineWidth: -1 }));
+                            if (verbose)
+                                console.log(`     ✓ Saved: ${outgoing.length} outgoing webhooks → ${connector.connector_idn}/webhooks/outgoing.yaml`);
+                        }
+                        if (incoming.length > 0) {
+                            const incomingFile = path.join(connectorWebhooksDir, 'incoming.yaml');
+                            await fs.writeFile(incomingFile, yaml.dump({ webhooks: incoming }, { lineWidth: -1 }));
+                            if (verbose)
+                                console.log(`     ✓ Saved: ${incoming.length} incoming webhooks → ${connector.connector_idn}/webhooks/incoming.yaml`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        if (verbose)
+            console.log(`⚠ Could not fetch webhooks: ${error.message}`);
+    }
+    // Save master integrations list
+    const integrationsData = { integrations: integrationsMetadata };
+    const integrationsFile = path.join(integrationsDir, 'integrations.yaml');
+    await fs.writeFile(integrationsFile, yaml.dump(integrationsData, { lineWidth: -1 }));
+    if (verbose)
+        console.log(`\n✅ Saved ${integrations.length} integrations to integrations/integrations.yaml\n`);
+}
+/**
+ * Push integration changes from local files to NEWO platform
+ */
+export async function pushIntegrations(client, customerDir, verbose = false) {
+    if (verbose)
+        console.log('\n📤 Pushing integration changes to NEWO platform...\n');
+    const integrationsDir = path.join(customerDir, 'integrations');
+    // Check if integrations directory exists
+    if (!await fs.pathExists(integrationsDir)) {
+        if (verbose)
+            console.log('⚠ No integrations directory found. Run pull-integrations first.');
+        return;
+    }
+    // Load remote integrations for ID mapping
+    const remoteIntegrations = await listIntegrations(client);
+    const integrationMap = new Map(); // idn -> id
+    remoteIntegrations.forEach(int => integrationMap.set(int.idn, int.id));
+    let updatedCount = 0;
+    let createdCount = 0;
+    let deletedCount = 0;
+    // Read integrations directory
+    const integrationFolders = await fs.readdir(integrationsDir);
+    for (const folder of integrationFolders) {
+        if (folder === 'integrations.yaml')
+            continue; // Skip master file
+        const integrationDir = path.join(integrationsDir, folder);
+        const stat = await fs.stat(integrationDir);
+        if (!stat.isDirectory())
+            continue;
+        const integrationIdn = folder;
+        const integrationId = integrationMap.get(integrationIdn);
+        if (!integrationId) {
+            if (verbose)
+                console.log(`⚠ Integration ${integrationIdn} not found on platform, skipping...`);
+            continue;
+        }
+        if (verbose)
+            console.log(`\n  📦 Processing: ${integrationIdn}`);
+        // Process connectors
+        const connectorsDir = path.join(integrationDir, 'connectors');
+        if (await fs.pathExists(connectorsDir)) {
+            // Load remote connectors for comparison
+            const remoteConnectors = await listConnectors(client, integrationId);
+            const remoteConnectorMap = new Map();
+            remoteConnectors.forEach(conn => remoteConnectorMap.set(conn.connector_idn, conn));
+            // Read connector subdirectories
+            const connectorDirs = await fs.readdir(connectorsDir);
+            const localConnectorIdns = new Set();
+            for (const connectorDirName of connectorDirs) {
+                const connectorPath = path.join(connectorsDir, connectorDirName);
+                const stat = await fs.stat(connectorPath);
+                if (!stat.isDirectory())
+                    continue; // Skip non-directories
+                // Read connector YAML file from within the subdirectory
+                const connectorFile = path.join(connectorPath, `${connectorDirName}.yaml`);
+                if (!await fs.pathExists(connectorFile)) {
+                    if (verbose)
+                        console.log(`     ⚠ No YAML file found in ${connectorDirName}/, skipping...`);
+                    continue;
+                }
+                const connectorData = yaml.load(await fs.readFile(connectorFile, 'utf-8'));
+                localConnectorIdns.add(connectorData.connector_idn);
+                const remoteConnector = remoteConnectorMap.get(connectorData.connector_idn);
+                if (!remoteConnector) {
+                    // Create new connector
+                    if (verbose)
+                        console.log(`     ➕ Creating connector: ${connectorData.title}`);
+                    try {
+                        await createConnector(client, integrationId, {
+                            title: connectorData.title,
+                            connector_idn: connectorData.connector_idn,
+                            integration_idn: integrationIdn,
+                            settings: connectorData.settings
+                        });
+                        createdCount++;
+                        if (verbose)
+                            console.log(`     ✅ Created: ${connectorData.title}`);
+                    }
+                    catch (error) {
+                        console.error(`     ❌ Failed to create connector: ${error.message}`);
+                    }
+                }
+                else {
+                    // Check if connector needs update
+                    const needsUpdate = hasConnectorChanged(remoteConnector, connectorData);
+                    if (needsUpdate) {
+                        if (verbose)
+                            console.log(`     🔄 Updating connector: ${connectorData.title}`);
+                        try {
+                            await updateConnector(client, remoteConnector.id, {
+                                title: connectorData.title,
+                                status: connectorData.status,
+                                settings: connectorData.settings
+                            });
+                            updatedCount++;
+                            if (verbose)
+                                console.log(`     ✅ Updated: ${connectorData.title}`);
+                        }
+                        catch (error) {
+                            console.error(`     ❌ Failed to update connector: ${error.message}`);
+                        }
+                    }
+                    else {
+                        if (verbose)
+                            console.log(`     ✓ No changes: ${connectorData.title}`);
+                    }
+                }
+            }
+            // Delete connectors that exist remotely but not locally
+            for (const [connectorIdn, remoteConnector] of remoteConnectorMap) {
+                if (!localConnectorIdns.has(connectorIdn)) {
+                    if (verbose)
+                        console.log(`     🗑️ Deleting connector: ${remoteConnector.title}`);
+                    try {
+                        await deleteConnector(client, remoteConnector.id);
+                        deletedCount++;
+                        if (verbose)
+                            console.log(`     ✅ Deleted: ${remoteConnector.title}`);
+                    }
+                    catch (error) {
+                        console.error(`     ❌ Failed to delete connector: ${error.message}`);
+                    }
+                }
+            }
+        }
+    }
+    // Always show summary if changes were made, not just in verbose mode
+    if (createdCount > 0 || updatedCount > 0 || deletedCount > 0) {
+        console.log(`\n✅ Integration push completed:`);
+        console.log(`   Created: ${createdCount} connector(s)`);
+        console.log(`   Updated: ${updatedCount} connector(s)`);
+        console.log(`   Deleted: ${deletedCount} connector(s)`);
+    }
+    else {
+        console.log(`\n✓ No connector changes to push`);
+    }
+}
+/**
+ * Check if connector has changed compared to remote version
+ */
+function hasConnectorChanged(remote, local) {
+    // Check title
+    if (remote.title !== local.title)
+        return true;
+    // Check status
+    if (remote.status !== local.status)
+        return true;
+    // Check settings
+    if (remote.settings.length !== local.settings.length)
+        return true;
+    // Compare each setting
+    const remoteSettingsMap = new Map();
+    remote.settings.forEach(s => remoteSettingsMap.set(s.idn, s.value));
+    for (const localSetting of local.settings) {
+        const remoteValue = remoteSettingsMap.get(localSetting.idn);
+        if (remoteValue !== localSetting.value)
+            return true;
+    }
+    return false;
+}
+/**
+ * List all local integrations from file system
+ */
+export async function listLocalIntegrations(customerDir) {
+    const integrationsFile = path.join(customerDir, 'integrations', 'integrations.yaml');
+    if (!await fs.pathExists(integrationsFile)) {
+        return [];
+    }
+    const data = yaml.load(await fs.readFile(integrationsFile, 'utf-8'));
+    return data.integrations;
+}
+/**
+ * Get connector details from local file
+ */
+export async function getLocalConnector(customerDir, integrationIdn, connectorIdn) {
+    const connectorFile = path.join(customerDir, 'integrations', integrationIdn, 'connectors', connectorIdn, `${connectorIdn}.yaml`);
+    if (!await fs.pathExists(connectorFile)) {
+        return null;
+    }
+    return yaml.load(await fs.readFile(connectorFile, 'utf-8'));
+}
+//# sourceMappingURL=integrations.js.map