@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/FluxCDConnector.js

@@ -0,0 +1,94 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "flux-reconcile",
+        name: "Reconciliation Status",
+        description: "Fetch FluxCD source and kustomization reconciliation status",
+        evidenceCategories: ["change_management", "monitoring"],
+    },
+    {
+        id: "flux-repositories",
+        name: "Git Repositories",
+        description: "Fetch GitRepository source configurations and drift detection",
+        evidenceCategories: ["access_control", "change_management"],
+    },
+    {
+        id: "flux-policies",
+        name: "Image Policies",
+        description: "Fetch image update automation and policies",
+        evidenceCategories: ["change_management", "data_protection"],
+    },
+    {
+        id: "flux-alerts",
+        name: "Alert Provider",
+        description: "Fetch alert configurations and notification status",
+        evidenceCategories: ["monitoring"],
+    },
+];
+export class FluxCDConnector {
+    id = "fluxcd";
+    name = "FluxCD";
+    category = "ci_cd";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://flux.example.com";
+        const resp = await fetch(`${base}/apis${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`FluxCD API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/kustomize.toolkit.fluxcd.io/v1/namespaces");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const ns = config.extra?.namespace || "flux-system";
+        const kustomizations = await this.fetchApi(config, `/kustomize.toolkit.fluxcd.io/v1/namespaces/${ns}/kustomizations`).catch(() => ({ items: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "flux-reconcile",
+            timestamp: now,
+            hash: hashEvidence(kustomizations),
+            framework: "SOC2",
+            controlId: "CC8.1",
+            source: `fluxcd/${ns}/kustomizations`,
+            status: kustomizations.items?.length > 0 ? "compliant" : "unknown",
+            data: { kustomizationCount: kustomizations.items?.length || 0 },
+            metadata: { namespace: ns },
+        });
+        const gitrepos = await this.fetchApi(config, `/source.toolkit.fluxcd.io/v1/namespaces/${ns}/gitrepositories`).catch(() => ({ items: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "flux-repositories",
+            timestamp: now,
+            hash: hashEvidence(gitrepos),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: `fluxcd/${ns}/gitrepositories`,
+            status: gitrepos.items?.length > 0 ? "compliant" : "non_compliant",
+            data: { gitRepositoryCount: gitrepos.items?.length || 0 },
+            metadata: { namespace: ns },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/ForgeRockConnector.d.ts

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

@@ -0,0 +1,95 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "forgerock-realms",
+        name: "Realm Configuration",
+        description: "Fetch authentication realms and chain configurations",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "forgerock-policies",
+        name: "Authorization Policies",
+        description: "Fetch policy decisions and access rules",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "forgerock-tokens",
+        name: "Session Tokens",
+        description: "Fetch token issuance and session management",
+        evidenceCategories: ["access_control", "monitoring"],
+    },
+    {
+        id: "forgerock-audit",
+        name: "Access Audit",
+        description: "Fetch authentication and authorization audit logs",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+];
+export class ForgeRockConnector {
+    id = "forgerock";
+    name = "ForgeRock";
+    category = "identity";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "HIPAA",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://forgerock.example.com";
+        const resp = await fetch(`${base}/openam/json${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+                "Accept-API-Version": "resource=2.1",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`ForgeRock API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/realms");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const realms = await this.fetchApi(config, "/realms").catch(() => ({ realmNames: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "forgerock-realms",
+            timestamp: now,
+            hash: hashEvidence(realms),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "forgerock/realms",
+            status: realms.realmNames?.length > 0 ? "compliant" : "unknown",
+            data: { realmCount: realms.realmNames?.length || 0 },
+            metadata: {},
+        });
+        const policies = await this.fetchApi(config, "/policies").catch(() => ({ result: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "forgerock-policies",
+            timestamp: now,
+            hash: hashEvidence(policies),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: "forgerock/policies",
+            status: policies.result?.length > 0 ? "compliant" : "non_compliant",
+            data: { policyCount: policies.result?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/FortinetConnector.d.ts

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

@@ -0,0 +1,98 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "fortinet-firewall",
+        name: "FortiGate Firewall",
+        description: "Fetch FortiGate firewall policies and interfaces",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "fortinet-ips",
+        name: "IPS Signatures",
+        description: "Fetch intrusion prevention signature status",
+        evidenceCategories: ["vulnerability_management", "monitoring"],
+    },
+    {
+        id: "fortinet-webfilter",
+        name: "Web Filtering",
+        description: "Fetch web filter profiles and URL categories",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "fortinet-logs",
+        name: "Security Logs",
+        description: "Fetch FortiGate event and traffic logs",
+        evidenceCategories: ["monitoring"],
+    },
+];
+export class FortinetConnector {
+    id = "fortinet";
+    name = "Fortinet FortiGate";
+    category = "cloud_provider";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "PCI_DSS",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://fortigate.example.com";
+        const resp = await fetch(`${base}/api/v2${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Fortinet API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/monitor/system/status");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const policies = await this.fetchApi(config, "/monitor/firewall/policy").catch(() => ({
+            results: [],
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "fortinet-firewall",
+            timestamp: now,
+            hash: hashEvidence(policies),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "fortinet/firewall/policies",
+            status: policies.results?.length > 0 ? "compliant" : "unknown",
+            data: { policyCount: policies.results?.length || 0 },
+            metadata: {},
+        });
+        const ips = await this.fetchApi(config, "/monitor/ips/signature").catch(() => ({
+            results: [],
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "fortinet-ips",
+            timestamp: now,
+            hash: hashEvidence(ips),
+            framework: "ISO27001",
+            controlId: "A.12.2.1",
+            source: "fortinet/ips/signatures",
+            status: ips.results?.length > 0 ? "compliant" : "non_compliant",
+            data: { signatureCount: ips.results?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/FreshdeskConnector.d.ts

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

@@ -0,0 +1,71 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "freshdesk-tickets",
+        name: "Support Tickets",
+        description: "Fetch Freshdesk ticket queue, SLA compliance, and resolution metrics",
+        evidenceCategories: ["incident_management", "monitoring"],
+    },
+    {
+        id: "freshdesk-security",
+        name: "Security Settings",
+        description: "Fetch Freshdesk SSO, 2FA enforcement, and agent access controls",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "freshdesk-audit",
+        name: "Audit Logs",
+        description: "Fetch Freshdesk audit log events for configuration and access changes",
+        evidenceCategories: ["audit", "change_management"],
+    },
+];
+export class FreshdeskConnector {
+    id = "freshdesk";
+    name = "Freshdesk";
+    category = "incident_management";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001"];
+    async fetchApi(config, endpoint) {
+        const domain = config.extra?.domain || "default";
+        const base = config.baseUrl || `https://${domain}.freshdesk.com/api/v2`;
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Freshdesk API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/agents/me.json");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const tickets = await this.fetchApi(config, "/tickets.json?per_page=100&order_by=created_at&order_type=desc").catch(() => []);
+        const ticketList = Array.isArray(tickets) ? tickets : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "freshdesk-tickets",
+            timestamp: now,
+            hash: hashEvidence({ ticketCount: ticketList.length }),
+            framework: "SOC2",
+            controlId: "CC7.3",
+            source: "freshdesk/tickets",
+            status: "unknown",
+            data: { recentTickets: ticketList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/GCPBigQueryConnector.d.ts

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

package/dist/connectors/GCPBigQueryConnector.js

@@ -0,0 +1,71 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "gcpbigquery-datasets",
+        name: "BigQuery Datasets",
+        description: "Fetch BigQuery dataset configurations and access controls",
+        evidenceCategories: ["data_protection", "cloud_configuration"],
+    },
+    {
+        id: "gcpbigquery-iam",
+        name: "Dataset IAM Policies",
+        description: "Fetch IAM bindings and authorized views on BigQuery datasets",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "gcpbigquery-audit",
+        name: "Query Audit Logs",
+        description: "Fetch BigQuery data access audit logs and query history",
+        evidenceCategories: ["monitoring", "audit"],
+    },
+];
+export class GCPBigQueryConnector {
+    id = "gcp-bigquery";
+    name = "GCP BigQuery";
+    category = "data_warehouse";
+    authType = "service_account";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "HIPAA"];
+    async fetchApi(config, endpoint) {
+        const project = config.extra?.project || "default";
+        const base = config.baseUrl || `https://bigquery.googleapis.com/bigquery/v2/projects/${project}`;
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`GCP BigQuery API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/datasets?maxResults=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const datasets = await this.fetchApi(config, "/datasets?maxResults=100").catch(() => ({ datasets: [] }));
+        const datasetList = (datasets.datasets || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gcpbigquery-datasets",
+            timestamp: now,
+            hash: hashEvidence({ datasetCount: datasetList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "gcp-bigquery/datasets",
+            status: datasetList.length > 0 ? "compliant" : "unknown",
+            data: { datasetCount: datasetList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/GCPComputeConnector.d.ts

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

package/dist/connectors/GCPComputeConnector.js

@@ -0,0 +1,87 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "gcpcompute-instances",
+        name: "Compute Instances",
+        description: "Fetch GCP Compute Engine instance configurations and metadata",
+        evidenceCategories: ["cloud_configuration", "infrastructure"],
+    },
+    {
+        id: "gcpcompute-firewall",
+        name: "Firewall Rules",
+        description: "Fetch VPC firewall rules and network access controls",
+        evidenceCategories: ["network_security", "access_control"],
+    },
+    {
+        id: "gcpcompute-osconfig",
+        name: "OS Patch Management",
+        description: "Fetch OS patch policies and compliance status for compute instances",
+        evidenceCategories: ["vulnerability_management", "configuration"],
+    },
+];
+export class GCPComputeConnector {
+    id = "gcp-compute";
+    name = "GCP Compute Engine";
+    category = "cloud_provider";
+    authType = "service_account";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "PCI_DSS"];
+    async fetchApi(config, endpoint) {
+        const project = config.extra?.project || "default";
+        const base = config.baseUrl || `https://compute.googleapis.com/compute/v1/projects/${project}`;
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`GCP Compute API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/aggregated/instances?maxResults=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const instances = await this.fetchApi(config, "/aggregated/instances").catch(() => ({ items: {} }));
+        const items = instances.items || {};
+        const instanceCount = Object.keys(items).length;
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gcpcompute-instances",
+            timestamp: now,
+            hash: hashEvidence({ instanceCount }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "gcp-compute/instances",
+            status: "unknown",
+            data: { instanceCount },
+            metadata: {},
+        });
+        const firewalls = await this.fetchApi(config, "/global/firewalls").catch(() => ({ items: [] }));
+        const fwList = (firewalls.items || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gcpcompute-firewall",
+            timestamp: now,
+            hash: hashEvidence({ ruleCount: fwList.length }),
+            framework: "ISO27001",
+            controlId: "A.13.1.1",
+            source: "gcp-compute/firewalls",
+            status: "unknown",
+            data: { firewallRuleCount: fwList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/GCPConfigConnector.d.ts

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