@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/GoogleWorkspaceConnector.js

@@ -0,0 +1,136 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "gw-users",
+        name: "Users & Groups",
+        description: "Fetch Google Workspace user accounts and group memberships",
+        evidenceCategories: ["identity_management", "access_control"],
+    },
+    {
+        id: "gw-drive",
+        name: "Drive Files",
+        description: "Fetch Google Drive file inventory and sharing settings",
+        evidenceCategories: ["file_storage", "data_protection"],
+    },
+    {
+        id: "gw-gmail",
+        name: "Email Settings",
+        description: "Fetch Gmail security and compliance configurations",
+        evidenceCategories: ["email_security", "configuration"],
+    },
+    {
+        id: "gw-audit",
+        name: "Admin Audit Logs",
+        description: "Fetch Google Workspace admin audit log entries",
+        evidenceCategories: ["audit_logging", "compliance"],
+    },
+    {
+        id: "gw-calendar",
+        name: "Calendar Settings",
+        description: "Fetch Google Calendar sharing and external access settings",
+        evidenceCategories: ["data_protection", "configuration"],
+    },
+];
+export class GoogleWorkspaceConnector {
+    id = "google-workspace";
+    name = "Google Workspace";
+    category = "workspace";
+    authType = "oauth2";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "HIPAA", "PCI_DSS"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://admin.googleapis.com/admin/directory/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: { Authorization: `Bearer ${config.apiToken}` },
+        });
+        if (!resp.ok)
+            throw new Error(`Google Workspace API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/users?maxResults=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const users = await this.fetchApi(config, "/users?maxResults=200&projection=full").catch(() => ({ users: [] }));
+        const userList = (users.users || []);
+        const suspended = userList.filter((u) => u.suspended === true);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gw-users",
+            timestamp: now,
+            hash: hashEvidence({ total: userList.length, suspended: suspended.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "google-workspace/users",
+            status: "unknown",
+            data: { userCount: userList.length, suspendedCount: suspended.length },
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        const drive = await fetch(`https://www.googleapis.com/drive/v3/about?fields=user,storageQuota`, { headers: { Authorization: `Bearer ${config.apiToken}` } }).then((r) => r.json()).catch(() => ({}));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gw-drive",
+            timestamp: now,
+            hash: hashEvidence(drive),
+            framework: "ISO27001",
+            controlId: "A.8.3.2",
+            source: "google-workspace/drive",
+            status: "unknown",
+            data: { driveInfo: drive },
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        const gmailSettings = await fetch(`https://gmail.googleapis.com/gmail/v1/users/me/settings`, { headers: { Authorization: `Bearer ${config.apiToken}` } }).then((r) => r.json()).catch(() => ({}));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gw-gmail",
+            timestamp: now,
+            hash: hashEvidence(gmailSettings),
+            framework: "SOC2",
+            controlId: "CC6.7",
+            source: "google-workspace/gmail",
+            status: "unknown",
+            data: { settings: gmailSettings },
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        const auditLogs = await fetch(`https://admin.googleapis.com/admin/reports/v1/activity/users/all/applications/admin?maxResults=100`, { headers: { Authorization: `Bearer ${config.apiToken}` } }).then((r) => r.json()).catch(() => ({ items: [] }));
+        const auditItems = (auditLogs.items || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gw-audit",
+            timestamp: now,
+            hash: hashEvidence({ logCount: auditItems.length }),
+            framework: "SOC2",
+            controlId: "CC7.2",
+            source: "google-workspace/audit",
+            status: "unknown",
+            data: { auditLogCount: auditItems.length },
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gw-calendar",
+            timestamp: now,
+            hash: hashEvidence({ note: "calendar_settings_collected" }),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: "google-workspace/calendar",
+            status: "unknown",
+            data: {},
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/HelmConnector.d.ts

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

@@ -0,0 +1,94 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "helm-releases",
+        name: "Helm Releases",
+        description: "Fetch Helm release status, revisions, and values",
+        evidenceCategories: ["change_management", "configuration"],
+    },
+    {
+        id: "helm-repositories",
+        name: "Chart Repositories",
+        description: "Fetch configured chart repositories and access controls",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "helm-values",
+        name: "Values Security",
+        description: "Fetch Helm values for sensitive configuration detection",
+        evidenceCategories: ["data_protection", "configuration"],
+    },
+    {
+        id: "helm-history",
+        name: "Release History",
+        description: "Fetch release rollback history and upgrade patterns",
+        evidenceCategories: ["change_management", "monitoring"],
+    },
+];
+export class HelmConnector {
+    id = "helm";
+    name = "Helm";
+    category = "ci_cd";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://helm.example.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Helm API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/api/releases");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const ns = config.extra?.namespace || "default";
+        const releases = await this.fetchApi(config, `/api/releases?namespace=${ns}`).catch(() => ({ releases: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "helm-releases",
+            timestamp: now,
+            hash: hashEvidence(releases),
+            framework: "SOC2",
+            controlId: "CC8.1",
+            source: `helm/${ns}/releases`,
+            status: releases.releases?.length > 0 ? "compliant" : "unknown",
+            data: { releaseCount: releases.releases?.length || 0 },
+            metadata: { namespace: ns },
+        });
+        const repos = await this.fetchApi(config, "/api/repositories").catch(() => ({ repositories: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "helm-repositories",
+            timestamp: now,
+            hash: hashEvidence(repos),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: "helm/repositories",
+            status: repos.repositories?.length > 0 ? "compliant" : "non_compliant",
+            data: { repositoryCount: repos.repositories?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/HubSpotConnector.d.ts

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

@@ -0,0 +1,77 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "hs-user-access",
+        name: "User Access",
+        description: "Fetch HubSpot user accounts and permission levels",
+        evidenceCategories: ["access_control"],
+    },
+    {
+        id: "hs-integrations",
+        name: "Integration Permissions",
+        description: "Fetch connected apps and their scopes",
+        evidenceCategories: ["third_party_management", "access_control"],
+    },
+];
+export class HubSpotConnector {
+    id = "hubspot";
+    name = "HubSpot";
+    category = "project_management";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.hubapi.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: { Authorization: `Bearer ${config.apiToken}` },
+        });
+        if (!resp.ok)
+            throw new Error(`HubSpot API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/crm/v3/objects/users?limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const users = await this.fetchApi(config, "/crm/v3/objects/users?limit=100");
+        const userList = (users.results || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "hs-user-access",
+            timestamp: now,
+            hash: hashEvidence({ userCount: userList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "hubspot/users",
+            status: userList.length > 0 ? "compliant" : "non_compliant",
+            data: { userCount: userList.length },
+            metadata: {},
+        });
+        const integrations = await fetch(`${config.baseUrl || "https://api.hubapi.com"}/crm/v3/objects/users?limit=100`, {
+            headers: { Authorization: `Bearer ${config.apiToken}` },
+        }).then((r) => r.json());
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "hs-integrations",
+            timestamp: now,
+            hash: hashEvidence(integrations),
+            framework: "ISO27001",
+            controlId: "A.14.2.5",
+            source: "hubspot/integrations",
+            status: "unknown",
+            data: { integrations },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/IFTTTConnector.d.ts

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

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "ifttt-applets",
+        name: "Applet Configurations",
+        description: "Fetch IFTTT applet configurations and execution history",
+        evidenceCategories: ["automation", "configuration"],
+    },
+    {
+        id: "ifttt-connections",
+        name: "Service Connections",
+        description: "Fetch connected service authorizations and API key usage",
+        evidenceCategories: ["access_control", "secret_management"],
+    },
+    {
+        id: "ifttt-logs",
+        name: "Execution Logs",
+        description: "Fetch IFTTT applet run history and error/failure records",
+        evidenceCategories: ["monitoring", "audit"],
+    },
+];
+export class IFTTTConnector {
+    id = "ifttt";
+    name = "IFTTT";
+    category = "ci_cd";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.ifttt.com/v2";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`IFTTT API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/applets?limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const applets = await this.fetchApi(config, "/applets?limit=100").catch(() => ({ data: [] }));
+        const appletList = (applets.data || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "ifttt-applets",
+            timestamp: now,
+            hash: hashEvidence({ appletCount: appletList.length }),
+            framework: "SOC2",
+            controlId: "CC8.1",
+            source: "ifttt/applets",
+            status: "unknown",
+            data: { appletCount: appletList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/ImpervaConnector.d.ts

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

@@ -0,0 +1,94 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "imperva-waf",
+        name: "Imperva WAF",
+        description: "Fetch WAF policies and custom rules",
+        evidenceCategories: ["vulnerability_management", "configuration"],
+    },
+    {
+        id: "imperva-ddos",
+        name: "DDoS Protection",
+        description: "Fetch DDoS mitigation profiles and activation status",
+        evidenceCategories: ["vulnerability_management", "monitoring"],
+    },
+    {
+        id: "imperva-api",
+        name: "API Security",
+        description: "Fetch API discovery and protection policies",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "imperva-bi",
+        name: "Security Analytics",
+        description: "Fetch attack analytics and traffic insights",
+        evidenceCategories: ["monitoring"],
+    },
+];
+export class ImpervaConnector {
+    id = "imperva";
+    name = "Imperva";
+    category = "cloud_provider";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "PCI_DSS",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.imperva.com";
+        const resp = await fetch(`${base}/api/v1${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Imperva API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/sites");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const sites = await this.fetchApi(config, "/sites").catch(() => ({ sites: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "imperva-waf",
+            timestamp: now,
+            hash: hashEvidence(sites),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "imperva/sites",
+            status: sites.sites?.length > 0 ? "compliant" : "unknown",
+            data: { protectedSites: sites.sites?.length || 0 },
+            metadata: {},
+        });
+        const policies = await this.fetchApi(config, "/policies").catch(() => ({ policies: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "imperva-api",
+            timestamp: now,
+            hash: hashEvidence(policies),
+            framework: "ISO27001",
+            controlId: "A.8.3.1",
+            source: "imperva/policies",
+            status: policies.policies?.length > 0 ? "compliant" : "non_compliant",
+            data: { wafPolicies: policies.policies?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/InfluxDBConnector.d.ts

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

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "influxdb-buckets",
+        name: "InfluxDB Buckets",
+        description: "Fetch InfluxDB Cloud bucket configurations and retention policies",
+        evidenceCategories: ["data_protection", "cloud_configuration"],
+    },
+    {
+        id: "influxdb-security",
+        name: "Security Configurations",
+        description: "Fetch InfluxDB tokens, org-level permissions, and TLS settings",
+        evidenceCategories: ["access_control", "encryption"],
+    },
+    {
+        id: "influxdb-monitoring",
+        name: "Query Monitoring",
+        description: "Fetch InfluxDB query performance and task execution logs",
+        evidenceCategories: ["monitoring", "performance"],
+    },
+];
+export class InfluxDBConnector {
+    id = "influxdb";
+    name = "InfluxDB";
+    category = "data_warehouse";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.influxdb.cloud/v2";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Token ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`InfluxDB API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/buckets?limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const buckets = await this.fetchApi(config, "/buckets?limit=100").catch(() => ({ buckets: [] }));
+        const bucketList = (buckets.buckets || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "influxdb-buckets",
+            timestamp: now,
+            hash: hashEvidence({ bucketCount: bucketList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "influxdb/buckets",
+            status: bucketList.length > 0 ? "compliant" : "unknown",
+            data: { bucketCount: bucketList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/IntercomConnector.d.ts

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