@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/OpsgenieConnector.js

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "opsgenie-incidents",
+        name: "Incident Management",
+        description: "Fetch Opsgenie incident timelines, escalation policies, and SLA metrics",
+        evidenceCategories: ["incident_management", "monitoring"],
+    },
+    {
+        id: "opsgenie-schedules",
+        name: "On-Call Schedules",
+        description: "Fetch on-call schedules, rotations, and escalation handoff records",
+        evidenceCategories: ["incident_management", "configuration"],
+    },
+    {
+        id: "opsgenie-integrations",
+        name: "Alert Integrations",
+        description: "Fetch Opsgenie alert integration configurations and forwarding rules",
+        evidenceCategories: ["configuration", "monitoring"],
+    },
+];
+export class OpsgenieConnector {
+    id = "opsgenie";
+    name = "Opsgenie";
+    category = "incident_management";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.opsgenie.com/v2";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `GenieKey ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Opsgenie 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 alerts = await this.fetchApi(config, "/alerts?limit=100").catch(() => ({ data: [] }));
+        const alertList = (alerts.data || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "opsgenie-incidents",
+            timestamp: now,
+            hash: hashEvidence({ alertCount: alertList.length }),
+            framework: "SOC2",
+            controlId: "CC7.3",
+            source: "opsgenie/alerts",
+            status: "unknown",
+            data: { openAlerts: alertList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/PagerDutyConnector.d.ts

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

@@ -0,0 +1,106 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "pagerduty-incidents-v2",
+        name: "Incident Management",
+        description: "Fetch PagerDuty incident lifecycle, escalation policies, and SLA compliance",
+        evidenceCategories: ["incident_management", "availability"],
+    },
+    {
+        id: "pagerduty-oncall-v2",
+        name: "On-Call Schedules",
+        description: "Fetch on-call schedules, rotations, and escalation handoff records",
+        evidenceCategories: ["incident_management", "configuration"],
+    },
+    {
+        id: "pagerduty-services-v2",
+        name: "Service Catalog",
+        description: "Fetch PagerDuty service health, integrations, and business impact mapping",
+        evidenceCategories: ["incident_management", "monitoring"],
+    },
+];
+export class PagerDutyConnector {
+    id = "pagerduty";
+    name = "PagerDuty";
+    category = "incident_management";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.pagerduty.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Token token=${config.apiToken}`,
+                Accept: "application/vnd.pagerduty+json;version=2",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`PagerDuty 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 services = await this.fetchApi(config, "/services?limit=100");
+        const serviceList = (services.services || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "pagerduty-services-v2",
+            timestamp: now,
+            hash: hashEvidence({ services: serviceList.map((s) => ({ id: s.id, name: s.name })) }),
+            framework: "SOC2",
+            controlId: "CC7.3",
+            source: "pagerduty/services",
+            status: serviceList.length > 0 ? "compliant" : "non_compliant",
+            data: { serviceCount: serviceList.length },
+            metadata: {},
+        });
+        const schedules = await this.fetchApi(config, "/schedules?limit=100").catch(() => ({
+            schedules: [],
+        }));
+        const scheduleList = (schedules.schedules || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "pagerduty-oncall-v2",
+            timestamp: now,
+            hash: hashEvidence({ schedules: scheduleList.map((s) => ({ id: s.id, name: s.name })) }),
+            framework: "SOC2",
+            controlId: "CC7.2",
+            source: "pagerduty/schedules",
+            status: scheduleList.length > 0 ? "compliant" : "non_compliant",
+            data: { scheduleCount: scheduleList.length },
+            metadata: {},
+        });
+        const since = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+        const incidents = await this.fetchApi(config, `/incidents?since=${since}&limit=100&statuses[]=triggered&statuses[]=resolved`).catch(() => ({ incidents: [] }));
+        const incidentList = (incidents.incidents || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "pagerduty-incidents-v2",
+            timestamp: now,
+            hash: hashEvidence({ incidents: incidentList.map((i) => ({ id: i.id, status: i.status })) }),
+            framework: "ISO27001",
+            controlId: "A.16.1.4",
+            source: "pagerduty/incidents",
+            status: "unknown",
+            data: {
+                incidentCount: incidentList.length,
+                resolved: incidentList.filter((i) => i.status === "resolved").length,
+            },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/PalantirConnector.d.ts

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

@@ -0,0 +1,95 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "palantir-foundry",
+        name: "Foundry Datasets",
+        description: "Fetch dataset access controls and lineage metadata",
+        evidenceCategories: ["data_protection", "access_control"],
+    },
+    {
+        id: "palantir-ontologies",
+        name: "Ontology Management",
+        description: "Fetch ontology object types and action permissions",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "palantir-pipelines",
+        name: "Data Pipelines",
+        description: "Fetch pipeline schedules and transformation configs",
+        evidenceCategories: ["change_management", "configuration"],
+    },
+    {
+        id: "palantir-audit",
+        name: "Audit Events",
+        description: "Fetch user activity and data access audit logs",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+];
+export class PalantirConnector {
+    id = "palantir";
+    name = "Palantir Foundry";
+    category = "data_warehouse";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "HIPAA",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://foundry.palantir.com";
+        const resp = await fetch(`${base}/api${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Palantir API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/datasets");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const project = config.extra?.project || "default";
+        const datasets = await this.fetchApi(config, `/datasets?project=${project}`).catch(() => ({ results: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "palantir-foundry",
+            timestamp: now,
+            hash: hashEvidence(datasets),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: `palantir/${project}/datasets`,
+            status: datasets.results?.length > 0 ? "compliant" : "unknown",
+            data: { datasetCount: datasets.results?.length || 0 },
+            metadata: { project },
+        });
+        const pipelines = await this.fetchApi(config, `/pipelines?project=${project}`).catch(() => ({ results: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "palantir-pipelines",
+            timestamp: now,
+            hash: hashEvidence(pipelines),
+            framework: "ISO27001",
+            controlId: "A.12.1.1",
+            source: `palantir/${project}/pipelines`,
+            status: pipelines.results?.length > 0 ? "compliant" : "non_compliant",
+            data: { pipelineCount: pipelines.results?.length || 0 },
+            metadata: { project },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/PaloAltoPrismaCloudConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class PaloAltoPrismaCloudConnector implements IntegrationConnector {
+    readonly id = "palo-alto-prisma-cloud";
+    readonly name = "Palo Alto Prisma Cloud";
+    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/PaloAltoPrismaCloudConnector.js

@@ -0,0 +1,110 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "prisma-cloud-compliance",
+        name: "Cloud Compliance posture",
+        description: "Fetch cloud compliance posture and misconfiguration alerts",
+        evidenceCategories: ["vulnerability_management", "configuration"],
+    },
+    {
+        id: "prisma-cloud-audit",
+        name: "Audit Logs",
+        description: "Fetch cloud audit logs and API activity",
+        evidenceCategories: ["access_control", "monitoring"],
+    },
+    {
+        id: "prisma-cloud-runtime",
+        name: "Runtime Protection",
+        description: "Fetch runtime protection policies and alerts",
+        evidenceCategories: ["vulnerability_management", "data_protection"],
+    },
+    {
+        id: "prisma-cloud-network",
+        name: "Network Security",
+        description: "Fetch network segmentation and firewall rules",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+];
+export class PaloAltoPrismaCloudConnector {
+    id = "palo-alto-prisma-cloud";
+    name = "Palo Alto Prisma Cloud";
+    category = "cloud_provider";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "PCI_DSS",
+        "HIPAA",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.prismacloud.io";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Prisma Cloud API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/api/v1/alert");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const cloudType = config.extra?.cloudType || "aws";
+        const compliance = await this.fetchApi(config, `/api/v1/compliance?cloudType=${cloudType}`).catch(() => ({ items: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "prisma-cloud-compliance",
+            timestamp: now,
+            hash: hashEvidence(compliance),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: `prismacloud.io/${cloudType}/compliance`,
+            status: compliance.items?.length === 0 ? "compliant" : "partial",
+            data: { complianceIssues: compliance.items?.length || 0 },
+            metadata: { cloudType },
+        });
+        const alerts = await this.fetchApi(config, `/api/v1/alert?status=open&limit=10`).catch(() => ({ items: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "prisma-cloud-audit",
+            timestamp: now,
+            hash: hashEvidence(alerts),
+            framework: "ISO27001",
+            controlId: "A.12.4.1",
+            source: `prismacloud.io/${cloudType}/alerts`,
+            status: alerts.items?.length === 0 ? "compliant" : "non_compliant",
+            data: { openAlerts: alerts.items?.length || 0 },
+            metadata: { cloudType },
+        });
+        const network = await this.fetchApi(config, `/api/v1/network/firewall?cloudType=${cloudType}`).catch(() => ({ items: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "prisma-cloud-network",
+            timestamp: now,
+            hash: hashEvidence(network),
+            framework: "NIST_CSF",
+            controlId: "PR.AC-5",
+            source: `prismacloud.io/${cloudType}/network`,
+            status: "partial",
+            data: { firewallRules: network.items?.length || 0 },
+            metadata: { cloudType },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/PingFederateConnector.d.ts

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

@@ -0,0 +1,97 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "pingfederate-sso",
+        name: "SSO Configuration",
+        description: "Fetch SAML/OIDC IdP configurations and SP partnerships",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "pingfederate-policies",
+        name: "Authentication Policies",
+        description: "Fetch authentication policy contracts and mappings",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "pingfederate-mfa",
+        name: "MFA Configuration",
+        description: "Fetch multi-factor authentication adapter settings",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "pingfederate-tokens",
+        name: "Token Management",
+        description: "Fetch OAuth token exchange and JWT settings",
+        evidenceCategories: ["access_control", "monitoring"],
+    },
+];
+export class PingFederateConnector {
+    id = "pingfederate";
+    name = "Ping Identity PingFederate";
+    category = "identity";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "HIPAA",
+        "PCI_DSS",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://pingfederate.example.com";
+        const resp = await fetch(`${base}/pf-admin-api/v1${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`PingFederate API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/version/info");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const idpAdapters = await this.fetchApi(config, "/idp/adapters").catch(() => ({ items: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "pingfederate-sso",
+            timestamp: now,
+            hash: hashEvidence(idpAdapters),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "pingfederate/idp-adapters",
+            status: idpAdapters.items?.length > 0 ? "compliant" : "unknown",
+            data: { idpAdapterCount: idpAdapters.items?.length || 0 },
+            metadata: {},
+        });
+        const spConnections = await this.fetchApi(config, "/idp/spConnections").catch(() => ({
+            items: [],
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "pingfederate-policies",
+            timestamp: now,
+            hash: hashEvidence(spConnections),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: "pingfederate/sp-connections",
+            status: spConnections.items?.length > 0 ? "compliant" : "non_compliant",
+            data: { spConnectionCount: spConnections.items?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/PostgreSQLCloudConnector.d.ts

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

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "pgcloud-instances",
+        name: "Database Instances",
+        description: "Fetch PostgreSQL Cloud instance configurations, versions, and storage",
+        evidenceCategories: ["data_protection", "cloud_configuration"],
+    },
+    {
+        id: "pgcloud-security",
+        name: "Security Configurations",
+        description: "Fetch SSL enforcement, IP whitelisting, and IAM authentication settings",
+        evidenceCategories: ["access_control", "encryption"],
+    },
+    {
+        id: "pgcloud-backups",
+        name: "Backup and Recovery",
+        description: "Fetch backup schedules, retention policies, and point-in-time recovery status",
+        evidenceCategories: ["data_protection", "disaster_recovery"],
+    },
+];
+export class PostgreSQLCloudConnector {
+    id = "postgresql-cloud";
+    name = "PostgreSQL Cloud";
+    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://api.postgres.cloud.example.com/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`PostgreSQL Cloud API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/clusters?limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const clusters = await this.fetchApi(config, "/clusters?limit=100").catch(() => ({ items: [] }));
+        const clusterList = (clusters.items || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "pgcloud-instances",
+            timestamp: now,
+            hash: hashEvidence({ clusterCount: clusterList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "postgresql-cloud/clusters",
+            status: clusterList.length > 0 ? "compliant" : "unknown",
+            data: { clusterCount: clusterList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/PowerBIConnector.d.ts

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