@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/CyberArkConnector.js

@@ -0,0 +1,95 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "cyberark-safe",
+        name: "Safe Management",
+        description: "Fetch safe configurations and access policies",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "cyberark-accounts",
+        name: "Account Management",
+        description: "Fetch managed accounts and rotation status",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "cyberark-psm",
+        name: "Session Monitoring",
+        description: "Fetch PSM session recordings and access logs",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+    {
+        id: "cyberark-policies",
+        name: "Password Policies",
+        description: "Fetch password complexity and rotation policies",
+        evidenceCategories: ["data_protection", "configuration"],
+    },
+];
+export class CyberArkConnector {
+    id = "cyberark";
+    name = "CyberArk";
+    category = "identity";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "PCI_DSS",
+        "HIPAA",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://cyberark.example.com";
+        const resp = await fetch(`${base}/PasswordVault/API${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`CyberArk API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/ Vaults");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const safes = await this.fetchApi(config, "/Vaults").catch(() => ({ value: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "cyberark-safe",
+            timestamp: now,
+            hash: hashEvidence(safes),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "cyberark/safes",
+            status: safes.value?.length > 0 ? "compliant" : "unknown",
+            data: { safeCount: safes.value?.length || 0 },
+            metadata: {},
+        });
+        const accounts = await this.fetchApi(config, "/Accounts").catch(() => ({ value: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "cyberark-accounts",
+            timestamp: now,
+            hash: hashEvidence(accounts),
+            framework: "ISO27001",
+            controlId: "A.9.2.6",
+            source: "cyberark/accounts",
+            status: accounts.value?.length > 0 ? "compliant" : "non_compliant",
+            data: { managedAccounts: accounts.value?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/DatabricksConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class DatabricksConnector implements IntegrationConnector {
+    readonly id = "databricks";
+    readonly name = "Databricks";
+    readonly category: "data_warehouse";
+    readonly authType: "api_key";
+    readonly capabilities: IntegrationCapability[];
+    readonly frameworks: ComplianceFramework[];
+    private fetchApi;
+    testConnection(config: ConnectorConfig): Promise<boolean>;
+    collectEvidence(config: ConnectorConfig): Promise<EvidenceArtifact[]>;
+}

package/dist/connectors/DatabricksConnector.js

@@ -0,0 +1,95 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "databricks-workspaces",
+        name: "Workspace Security",
+        description: "Fetch workspace access controls and Unity Catalog permissions",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "databricks-jobs",
+        name: "Job Configurations",
+        description: "Fetch job definitions and cluster configurations",
+        evidenceCategories: ["change_management", "configuration"],
+    },
+    {
+        id: "databricks-data-governance",
+        name: "Data Governance",
+        description: "Fetch data lineage, classification tags, and access policies",
+        evidenceCategories: ["data_protection", "compliance"],
+    },
+    {
+        id: "databricks-audit",
+        name: "Audit Logs",
+        description: "Fetch workspace audit log events",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+];
+export class DatabricksConnector {
+    id = "databricks";
+    name = "Databricks";
+    category = "data_warehouse";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "HIPAA",
+        "PCI_DSS",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://adb-default.cloud.databricks.com";
+        const resp = await fetch(`${base}/api/2.0${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Databricks API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/clusters/list");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const clusters = await this.fetchApi(config, "/clusters/list").catch(() => ({ clusters: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "databricks-workspaces",
+            timestamp: now,
+            hash: hashEvidence(clusters),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "databricks/clusters",
+            status: clusters.clusters?.length > 0 ? "compliant" : "unknown",
+            data: { clusterCount: clusters.clusters?.length || 0 },
+            metadata: {},
+        });
+        const jobs = await this.fetchApi(config, "/jobs/list").catch(() => ({ jobs: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "databricks-jobs",
+            timestamp: now,
+            hash: hashEvidence(jobs),
+            framework: "ISO27001",
+            controlId: "A.12.1.1",
+            source: "databricks/jobs",
+            status: jobs.jobs?.length > 0 ? "compliant" : "non_compliant",
+            data: { jobCount: jobs.jobs?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/DatadogConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class DatadogConnector implements IntegrationConnector {
+    readonly id = "datadog";
+    readonly name = "Datadog";
+    readonly category: "monitoring";
+    readonly authType: "api_key";
+    readonly capabilities: IntegrationCapability[];
+    readonly frameworks: ComplianceFramework[];
+    private fetchApi;
+    testConnection(config: ConnectorConfig): Promise<boolean>;
+    collectEvidence(config: ConnectorConfig): Promise<EvidenceArtifact[]>;
+}

package/dist/connectors/DatadogConnector.js

@@ -0,0 +1,110 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "dd-monitors",
+        name: "Monitors",
+        description: "Fetch Datadog monitor configurations and alert states",
+        evidenceCategories: ["monitoring", "configuration"],
+    },
+    {
+        id: "dd-alerts",
+        name: "Alerts",
+        description: "Fetch triggered alerts and alert rule configurations",
+        evidenceCategories: ["monitoring", "incident_detection"],
+    },
+    {
+        id: "dd-apm",
+        name: "APM Configurations",
+        description: "Fetch APM service configurations and security tracking",
+        evidenceCategories: ["application_security", "monitoring"],
+    },
+];
+export class DatadogConnector {
+    id = "datadog";
+    name = "Datadog";
+    category = "monitoring";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001"];
+    async fetchApi(config, endpoint, method = "GET") {
+        const site = config.extra?.site || "datadoghq.com";
+        const base = `https://api.${site}`;
+        const resp = await fetch(`${base}${endpoint}`, {
+            method,
+            headers: {
+                "DD-API-KEY": config.apiToken || "",
+                "DD-APPLICATION-KEY": config.extra?.appKey || "",
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Datadog API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/api/v1/validate");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const monitors = await this.fetchApi(config, "/api/v1/monitor");
+        const monitorList = Array.isArray(monitors) ? monitors : [];
+        const activeMonitors = monitorList.filter((m) => m.overall_state === "OK");
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "dd-monitors",
+            timestamp: now,
+            hash: hashEvidence({ monitorCount: monitorList.length }),
+            framework: "SOC2",
+            controlId: "CC7.1",
+            source: "datadog/monitors",
+            status: monitorList.length > 0 ? "compliant" : "non_compliant",
+            data: {
+                totalMonitors: monitorList.length,
+                activeMonitors: activeMonitors.length,
+                alertMonitors: monitorList.length - activeMonitors.length,
+            },
+            metadata: { site: config.extra?.site || "datadoghq.com" },
+        });
+        const alerts = await this.fetchApi(config, "/api/v1/alerts").catch(() => []);
+        const alertList = Array.isArray(alerts) ? alerts : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "dd-alerts",
+            timestamp: now,
+            hash: hashEvidence({ alertCount: alertList.length }),
+            framework: "SOC2",
+            controlId: "CC7.2",
+            source: "datadog/alerts",
+            status: "unknown",
+            data: { alertRuleCount: alertList.length },
+            metadata: { site: config.extra?.site || "datadoghq.com" },
+        });
+        const services = await this.fetchApi(config, "/api/v1/services").catch(() => ({
+            services: [],
+        }));
+        const serviceList = (services.services || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "dd-apm",
+            timestamp: now,
+            hash: hashEvidence({ serviceCount: serviceList.length }),
+            framework: "ISO27001",
+            controlId: "A.12.4.1",
+            source: "datadog/services",
+            status: "unknown",
+            data: { serviceCount: serviceList.length },
+            metadata: { site: config.extra?.site || "datadoghq.com" },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/DigitalOceanConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class DigitalOceanConnector implements IntegrationConnector {
+    readonly id = "digitalocean";
+    readonly name = "DigitalOcean";
+    readonly category: "cloud_provider";
+    readonly authType: "bearer_token";
+    readonly capabilities: IntegrationCapability[];
+    readonly frameworks: ComplianceFramework[];
+    private fetchApi;
+    testConnection(config: ConnectorConfig): Promise<boolean>;
+    collectEvidence(config: ConnectorConfig): Promise<EvidenceArtifact[]>;
+}

package/dist/connectors/DigitalOceanConnector.js

@@ -0,0 +1,85 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "do-droplets",
+        name: "Droplets",
+        description: "Fetch DigitalOcean droplet configurations and status",
+        evidenceCategories: ["cloud_configuration", "infrastructure"],
+    },
+    {
+        id: "do-firewalls",
+        name: "Cloud Firewalls",
+        description: "Fetch cloud firewall rules and inbound/outbound policies",
+        evidenceCategories: ["network_security", "access_control"],
+    },
+    {
+        id: "do-vpc",
+        name: "VPC Networks",
+        description: "Fetch VPC configurations and IP range allocations",
+        evidenceCategories: ["network_security", "cloud_configuration"],
+    },
+];
+export class DigitalOceanConnector {
+    id = "digitalocean";
+    name = "DigitalOcean";
+    category = "cloud_provider";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.digitalocean.com/v2";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`DigitalOcean API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/account");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const droplets = await this.fetchApi(config, "/droplets?per_page=100").catch(() => ({ droplets: [] }));
+        const dropletList = (droplets.droplets || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "do-droplets",
+            timestamp: now,
+            hash: hashEvidence({ dropletCount: dropletList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "digitalocean/droplets",
+            status: "unknown",
+            data: { dropletCount: dropletList.length },
+            metadata: {},
+        });
+        const firewalls = await this.fetchApi(config, "/firewalls").catch(() => ({ firewalls: [] }));
+        const fwList = (firewalls.firewalls || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "do-firewalls",
+            timestamp: now,
+            hash: hashEvidence({ firewallCount: fwList.length }),
+            framework: "ISO27001",
+            controlId: "A.13.1.1",
+            source: "digitalocean/firewalls",
+            status: fwList.length > 0 ? "compliant" : "non_compliant",
+            data: { firewallCount: fwList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/DiscordConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class DiscordConnector implements IntegrationConnector {
+    readonly id = "discord";
+    readonly name = "Discord";
+    readonly category: "communication";
+    readonly authType: "api_key";
+    readonly capabilities: IntegrationCapability[];
+    readonly frameworks: ComplianceFramework[];
+    private fetchApi;
+    testConnection(config: ConnectorConfig): Promise<boolean>;
+    collectEvidence(config: ConnectorConfig): Promise<EvidenceArtifact[]>;
+}

package/dist/connectors/DiscordConnector.js

@@ -0,0 +1,98 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "discord-servers",
+        name: "Server Settings",
+        description: "Fetch Discord server verification and security settings",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "discord-roles",
+        name: "Role Management",
+        description: "Fetch server roles and permission configurations",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "discord-audit",
+        name: "Audit Logs",
+        description: "Fetch Discord server audit log entries",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+    {
+        id: "discord-integrations",
+        name: "Bot & Webhook Security",
+        description: "Fetch bot permissions and webhook configurations",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+];
+export class DiscordConnector {
+    id = "discord";
+    name = "Discord";
+    category = "communication";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://discord.com/api/v10";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bot ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Discord API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/users/@me");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const guildId = config.extra?.guildId || "";
+        const guild = await this.fetchApi(config, `/guilds/${guildId}?with_counts=true`).catch(() => ({}));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "discord-servers",
+            timestamp: now,
+            hash: hashEvidence(guild),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: `discord/${guildId}`,
+            status: guild.id ? "compliant" : "unknown",
+            data: {
+                name: guild.name,
+                verificationLevel: guild.verification_level,
+                mfaLevel: guild.mfa_level,
+            },
+            metadata: { guildId },
+        });
+        const roles = await this.fetchApi(config, `/guilds/${guildId}/roles`).catch(() => []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "discord-roles",
+            timestamp: now,
+            hash: hashEvidence(Array.isArray(roles) ? { count: roles.length } : roles),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: `discord/${guildId}/roles`,
+            status: Array.isArray(roles) && roles.length > 0 ? "compliant" : "non_compliant",
+            data: { roleCount: Array.isArray(roles) ? roles.length : 0 },
+            metadata: { guildId },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/DockerHubConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class DockerHubConnector implements IntegrationConnector {
+    readonly id = "docker-hub";
+    readonly name = "Docker Hub";
+    readonly category: "container";
+    readonly authType: "bearer_token";
+    readonly capabilities: IntegrationCapability[];
+    readonly frameworks: ComplianceFramework[];
+    private fetchApi;
+    testConnection(config: ConnectorConfig): Promise<boolean>;
+    collectEvidence(config: ConnectorConfig): Promise<EvidenceArtifact[]>;
+}

package/dist/connectors/DockerHubConnector.js

@@ -0,0 +1,80 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "docker-image-scans",
+        name: "Image Scans",
+        description: "Fetch Docker Hub image vulnerability scan results",
+        evidenceCategories: ["container_security", "vulnerability_management"],
+    },
+    {
+        id: "docker-vuln-reports",
+        name: "Vulnerability Reports",
+        description: "Fetch detailed vulnerability reports per image tag",
+        evidenceCategories: ["vulnerability_management", "supply_chain"],
+    },
+];
+export class DockerHubConnector {
+    id = "docker-hub";
+    name = "Docker Hub";
+    category = "container";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://hub.docker.com/v2";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: { Authorization: `Bearer ${config.apiToken}` },
+        });
+        if (!resp.ok)
+            throw new Error(`Docker Hub API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/user/");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const namespace = config.extra?.namespace || "library";
+        const repo = config.extra?.repo || "nginx";
+        const images = await this.fetchApi(config, `/repositories/${namespace}/${repo}/tags?page_size=50`).catch(() => ({ results: [] }));
+        const tagList = (images.results || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "docker-image-scans",
+            timestamp: now,
+            hash: hashEvidence({ tagCount: tagList.length }),
+            framework: "SOC2",
+            controlId: "CC6.8",
+            source: `dockerhub/${namespace}/${repo}/tags`,
+            status: tagList.length > 0 ? "compliant" : "non_compliant",
+            data: { tagCount: tagList.length, tags: tagList.map((t) => t.name) },
+            metadata: { namespace, repo },
+        });
+        const vulnReport = tagList.length > 0
+            ? await this.fetchApi(config, `/repositories/${namespace}/${repo}/tags/${tagList[0].name}/vulnerabilities`).catch(() => ({ vulnerabilities: [] }))
+            : { vulnerabilities: [] };
+        const vulns = (vulnReport.vulnerabilities || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "docker-vuln-reports",
+            timestamp: now,
+            hash: hashEvidence({ vulnCount: vulns.length }),
+            framework: "ISO27001",
+            controlId: "A.12.6.1",
+            source: `dockerhub/${namespace}/${repo}/vulnerabilities`,
+            status: vulns.length === 0 ? "compliant" : "non_compliant",
+            data: { totalVulnerabilities: vulns.length },
+            metadata: { namespace, repo },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/DocuSignConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class DocuSignConnector implements IntegrationConnector {
+    readonly id = "docusign";
+    readonly name = "DocuSign";
+    readonly category: "finance";
+    readonly authType: "api_key";
+    readonly capabilities: IntegrationCapability[];
+    readonly frameworks: ComplianceFramework[];
+    private fetchApi;
+    testConnection(config: ConnectorConfig): Promise<boolean>;
+    collectEvidence(config: ConnectorConfig): Promise<EvidenceArtifact[]>;
+}