@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/BitbucketPipelinesConnector.js

@@ -0,0 +1,72 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "bitbucket-pipelines-config",
+        name: "Pipeline Configuration",
+        description: "Fetch Bitbucket Pipelines YAML configurations and default branches",
+        evidenceCategories: ["ci_cd", "change_management"],
+    },
+    {
+        id: "bitbucket-pipelines-runs",
+        name: "Pipeline Runs",
+        description: "Fetch pipeline execution history and failure rates",
+        evidenceCategories: ["ci_cd", "monitoring"],
+    },
+    {
+        id: "bitbucket-pipelines-deployments",
+        name: "Deployment Environments",
+        description: "Fetch deployment environment configurations and approval rules",
+        evidenceCategories: ["access_control", "change_management"],
+    },
+];
+export class BitbucketPipelinesConnector {
+    id = "bitbucket-pipelines";
+    name = "Bitbucket Pipelines";
+    category = "ci_cd";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async fetchApi(config, endpoint) {
+        const workspace = config.extra?.workspace || "default";
+        const repo = config.extra?.repo || "main-repo";
+        const base = config.baseUrl || "https://api.bitbucket.org/2.0";
+        const resp = await fetch(`${base}/repositories/${workspace}/${repo}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Bitbucket API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const pipelines = await this.fetchApi(config, "/pipelines/?pagelen=100").catch(() => ({ values: [] }));
+        const pipelineList = (pipelines.values || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "bitbucket-pipelines-runs",
+            timestamp: now,
+            hash: hashEvidence({ runCount: pipelineList.length }),
+            framework: "SOC2",
+            controlId: "CC8.1",
+            source: "bitbucket-pipelines/runs",
+            status: "unknown",
+            data: { pipelineRunCount: pipelineList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/BoxConnector.d.ts

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

package/dist/connectors/BoxConnector.js

@@ -0,0 +1,122 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "box-folders",
+        name: "Folders & Structure",
+        description: "Fetch Box folder hierarchy and shared folder configurations",
+        evidenceCategories: ["document_management", "data_protection"],
+    },
+    {
+        id: "box-collaborations",
+        name: "Collaborations",
+        description: "Fetch collaboration invitations and access permissions",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "box-retention-policies",
+        name: "Retention Policies",
+        description: "Fetch Box retention and disposal policy configurations",
+        evidenceCategories: ["data_protection", "compliance"],
+    },
+    {
+        id: "box-events",
+        name: "File Events",
+        description: "Fetch recent file upload, download, and access events",
+        evidenceCategories: ["audit_logging", "data_protection"],
+    },
+];
+export class BoxConnector {
+    id = "box";
+    name = "Box";
+    category = "document_management";
+    authType = "oauth2";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "HIPAA", "PCI_DSS"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.box.com/2.0";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: { Authorization: `Bearer ${config.apiToken}` },
+        });
+        if (!resp.ok)
+            throw new Error(`Box 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 folders = await this.fetchApi(config, "/folders/0/items?limit=100").catch(() => ({ entries: [] }));
+        const folderList = (folders.entries || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "box-folders",
+            timestamp: now,
+            hash: hashEvidence({ itemCount: folderList.length }),
+            framework: "SOC2",
+            controlId: "CC6.4",
+            source: "box/folders",
+            status: folderList.length > 0 ? "compliant" : "non_compliant",
+            data: { itemCount: folderList.length },
+            metadata: {},
+        });
+        const collaborations = await this.fetchApi(config, "/collaborations?limit=100").catch(() => ({ entries: [] }));
+        const collabList = (collaborations.entries || []);
+        const externalCollabs = collabList.filter((c) => {
+            const access = (c.access_level || {});
+            return access.is_externally_managed === true;
+        });
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "box-collaborations",
+            timestamp: now,
+            hash: hashEvidence({ total: collabList.length, external: externalCollabs.length }),
+            framework: "ISO27001",
+            controlId: "A.9.2.5",
+            source: "box/collaborations",
+            status: externalCollabs.length === 0 ? "compliant" : "non_compliant",
+            data: { totalCollaborations: collabList.length, externalCollaborations: externalCollabs.length },
+            metadata: {},
+        });
+        const retentionPolicies = await this.fetchApi(config, "/retention_policies").catch(() => ({ entries: [] }));
+        const policyList = (retentionPolicies.entries || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "box-retention-policies",
+            timestamp: now,
+            hash: hashEvidence({ policyCount: policyList.length }),
+            framework: "ISO27001",
+            controlId: "A.8.3.2",
+            source: "box/retention_policies",
+            status: policyList.length > 0 ? "compliant" : "non_compliant",
+            data: { retentionPolicyCount: policyList.length },
+            metadata: {},
+        });
+        const events = await this.fetchApi(config, "/events?stream_type=admin_logs&limit=100").catch(() => ({ entries: [] }));
+        const eventList = (events.entries || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "box-events",
+            timestamp: now,
+            hash: hashEvidence({ eventCount: eventList.length }),
+            framework: "SOC2",
+            controlId: "CC7.2",
+            source: "box/events",
+            status: "unknown",
+            data: { eventCount: eventList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/BuildkiteConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class BuildkiteConnector implements IntegrationConnector {
+    readonly id = "buildkite";
+    readonly name = "Buildkite";
+    readonly category: "ci_cd";
+    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/BuildkiteConnector.js

@@ -0,0 +1,95 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "buildkite-pipelines",
+        name: "Pipeline Configurations",
+        description: "Fetch pipeline definitions and step configurations",
+        evidenceCategories: ["change_management", "configuration"],
+    },
+    {
+        id: "buildkite-builds",
+        name: "Build Results",
+        description: "Fetch build history and test results",
+        evidenceCategories: ["change_management", "monitoring"],
+    },
+    {
+        id: "buildkite-agents",
+        name: "Agent Pools",
+        description: "Fetch agent pool configurations and fleet status",
+        evidenceCategories: ["infrastructure", "configuration"],
+    },
+    {
+        id: "buildkite-secrets",
+        name: "Secret Management",
+        description: "Fetch encrypted secrets and environment configurations",
+        evidenceCategories: ["data_protection", "access_control"],
+    },
+];
+export class BuildkiteConnector {
+    id = "buildkite";
+    name = "Buildkite";
+    category = "ci_cd";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.buildkite.com/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Buildkite API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/organizations");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const org = config.extra?.org || "default";
+        const pipeline = config.extra?.pipeline || "main";
+        const builds = await this.fetchApi(config, `/organizations/${org}/pipelines/${pipeline}/builds?per_page=10`).catch(() => []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "buildkite-pipelines",
+            timestamp: now,
+            hash: hashEvidence(Array.isArray(builds) ? { builds: builds.length } : builds),
+            framework: "SOC2",
+            controlId: "CC8.1",
+            source: `buildkite.com/${org}/${pipeline}`,
+            status: Array.isArray(builds) && builds.length > 0 ? "compliant" : "unknown",
+            data: { recentBuilds: Array.isArray(builds) ? builds.length : 0 },
+            metadata: { org, pipeline },
+        });
+        const agents = await this.fetchApi(config, `/organizations/${org}/agent-groups`).catch(() => []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "buildkite-agents",
+            timestamp: now,
+            hash: hashEvidence(Array.isArray(agents) ? { groups: agents.length } : agents),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: `buildkite.com/${org}/agents`,
+            status: "partial",
+            data: { agentGroups: Array.isArray(agents) ? agents.length : 0 },
+            metadata: { org },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/CarbonBlackConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class CarbonBlackConnector implements IntegrationConnector {
+    readonly id = "carbonblack";
+    readonly name = "VMware Carbon Black";
+    readonly category: "endpoint";
+    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/CarbonBlackConnector.js

@@ -0,0 +1,89 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "carbonblack-endpoints",
+        name: "Endpoint Protection",
+        description: "Fetch Carbon Black sensor status and policy assignments",
+        evidenceCategories: ["endpoint", "monitoring"],
+    },
+    {
+        id: "carbonblack-alerts",
+        name: "Security Alerts",
+        description: "Fetch alert severity and investigation status",
+        evidenceCategories: ["vulnerability_management", "monitoring"],
+    },
+    {
+        id: "carbonblack-policies",
+        name: "Response Policies",
+        description: "Fetch prevention and response policy configurations",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "carbonblack-live-response",
+        name: "Live Response",
+        description: "Fetch live response session logs and forensics",
+        evidenceCategories: ["monitoring", "change_management"],
+    },
+];
+export class CarbonBlackConnector {
+    id = "carbonblack";
+    name = "VMware Carbon Black";
+    category = "endpoint";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "HIPAA", "PCI_DSS"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://defense.conferdeploy.net";
+        const resp = await fetch(`${base}/api/v6${endpoint}`, {
+            headers: {
+                "X-Auth-Token": config.apiToken || "",
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Carbon Black API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/apps/search");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const sensors = await this.fetchApi(config, "/sensors").catch(() => ({ results: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "carbonblack-endpoints",
+            timestamp: now,
+            hash: hashEvidence(sensors),
+            framework: "SOC2",
+            controlId: "CC6.8",
+            source: "carbonblack/sensors",
+            status: sensors.results?.length > 0 ? "compliant" : "unknown",
+            data: { sensorCount: sensors.results?.length || 0 },
+            metadata: {},
+        });
+        const alerts = await this.fetchApi(config, "/alerts/search").catch(() => ({ results: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "carbonblack-alerts",
+            timestamp: now,
+            hash: hashEvidence(alerts),
+            framework: "ISO27001",
+            controlId: "A.12.2.1",
+            source: "carbonblack/alerts",
+            status: alerts.results?.length === 0 ? "compliant" : "non_compliant",
+            data: { openAlerts: alerts.results?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/CassandraConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class CassandraConnector implements IntegrationConnector {
+    readonly id = "cassandra";
+    readonly name = "Apache Cassandra";
+    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/CassandraConnector.js

@@ -0,0 +1,69 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "cassandra-clusters",
+        name: "Cassandra Clusters",
+        description: "Fetch Cassandra cluster configurations and node status",
+        evidenceCategories: ["data_protection", "infrastructure"],
+    },
+    {
+        id: "cassandra-security",
+        name: "Security Configurations",
+        description: "Fetch Cassandra authentication, authorization, and TLS settings",
+        evidenceCategories: ["access_control", "encryption"],
+    },
+    {
+        id: "cassandra-backups",
+        name: "Backup Status",
+        description: "Fetch Cassandra snapshot backups and repair status",
+        evidenceCategories: ["data_protection", "disaster_recovery"],
+    },
+];
+export class CassandraConnector {
+    id = "cassandra";
+    name = "Apache Cassandra";
+    category = "data_warehouse";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.cassandra.example.com/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Cassandra API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/cluster/status");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const status = await this.fetchApi(config, "/cluster/status").catch(() => ({}));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "cassandra-clusters",
+            timestamp: now,
+            hash: hashEvidence(status),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "cassandra/cluster",
+            status: "unknown",
+            data: { connected: true },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/CheckPointConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class CheckPointConnector implements IntegrationConnector {
+    readonly id = "checkpoint";
+    readonly name = "Check Point";
+    readonly category: "cloud_provider";
+    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/CheckPointConnector.js

@@ -0,0 +1,98 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "checkpoint-firewall",
+        name: "Firewall Policies",
+        description: "Fetch firewall rule base and policy compliance",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "checkpoint-vpn",
+        name: "VPN Configuration",
+        description: "Fetch VPN tunnel status and encryption settings",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "checkpoint-threat",
+        name: "Threat Prevention",
+        description: "Fetch threat prevention profiles andblade status",
+        evidenceCategories: ["vulnerability_management", "monitoring"],
+    },
+    {
+        id: "checkpoint-logs",
+        name: "Security Logs",
+        description: "Fetch security gateway logs and traffic analysis",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+];
+export class CheckPointConnector {
+    id = "checkpoint";
+    name = "Check Point";
+    category = "cloud_provider";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "PCI_DSS",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://cp-management.example.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Check Point API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/api/v1/show-gateways");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const gateways = await this.fetchApi(config, "/api/v1/show-gateways").catch(() => ({
+            objects: [],
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "checkpoint-firewall",
+            timestamp: now,
+            hash: hashEvidence(gateways),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "checkpoint/gateways",
+            status: gateways.objects?.length > 0 ? "compliant" : "unknown",
+            data: { gateways: gateways.objects?.length || 0 },
+            metadata: {},
+        });
+        const threats = await this.fetchApi(config, "/api/v1/show-threat-profiles").catch(() => ({
+            objects: [],
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "checkpoint-threat",
+            timestamp: now,
+            hash: hashEvidence(threats),
+            framework: "ISO27001",
+            controlId: "A.12.2.1",
+            source: "checkpoint/threat-profiles",
+            status: threats.objects?.length > 0 ? "compliant" : "non_compliant",
+            data: { threatProfiles: threats.objects?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/CircleCIConnector.d.ts

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