@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/AkamaiConnector.js

@@ -0,0 +1,98 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "akamai-waf",
+        name: "Web Application Firewall",
+        description: "Fetch WAF policies and attack group configurations",
+        evidenceCategories: ["vulnerability_management", "configuration"],
+    },
+    {
+        id: "akamai-bot",
+        name: "Bot Manager",
+        description: "Fetch bot detection policies and blocked requests",
+        evidenceCategories: ["access_control", "monitoring"],
+    },
+    {
+        id: "akamai-edge",
+        name: "Edge Security",
+        description: "Fetch edge configuration and mPulse data",
+        evidenceCategories: ["configuration", "monitoring"],
+    },
+    {
+        id: "akamai-api",
+        name: "API Gateway",
+        description: "Fetch API endpoint security and rate limiting rules",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+];
+export class AkamaiConnector {
+    id = "akamai";
+    name = "Akamai";
+    category = "cloud_provider";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "PCI_DSS",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://akab-akabapi.luna.akamaiapis.net";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Akamai API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/config/v1/security-policies");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const policies = await this.fetchApi(config, "/config/v1/security-policies").catch(() => ({
+            policies: [],
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "akamai-waf",
+            timestamp: now,
+            hash: hashEvidence(policies),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "akamai/security-policies",
+            status: policies.policies?.length > 0 ? "compliant" : "unknown",
+            data: { securityPolicies: policies.policies?.length || 0 },
+            metadata: {},
+        });
+        const bot = await this.fetchApi(config, "/config/v1/bot-managers").catch(() => ({
+            managers: [],
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "akamai-bot",
+            timestamp: now,
+            hash: hashEvidence(bot),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: "akamai/bot-managers",
+            status: bot.managers?.length > 0 ? "compliant" : "partial",
+            data: { botManagers: bot.managers?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/ArgoCDConnector.d.ts

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

@@ -0,0 +1,93 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "argocd-apps",
+        name: "Application Definitions",
+        description: "Fetch ArgoCD application sync status and health",
+        evidenceCategories: ["change_management", "configuration"],
+    },
+    {
+        id: "argocd-repos",
+        name: "Repository Credentials",
+        description: "Fetch configured repository connections and RBAC",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "argocd-projects",
+        name: "App Projects",
+        description: "Fetch project restrictions and source/repo allowlists",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "argocd-audit",
+        name: "Audit Logs",
+        description: "Fetch ArgoCD event and audit logs",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+];
+export class ArgoCDConnector {
+    id = "argocd";
+    name = "Argo CD";
+    category = "ci_cd";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://argocd.example.com";
+        const resp = await fetch(`${base}/api/v1${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`ArgoCD 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 apps = await this.fetchApi(config, "/applications").catch(() => ({ items: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "argocd-apps",
+            timestamp: now,
+            hash: hashEvidence(apps),
+            framework: "SOC2",
+            controlId: "CC8.1",
+            source: "argocd/applications",
+            status: apps.items?.length > 0 ? "compliant" : "unknown",
+            data: { applicationCount: apps.items?.length || 0 },
+            metadata: {},
+        });
+        const projects = await this.fetchApi(config, "/projects").catch(() => ({ items: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "argocd-projects",
+            timestamp: now,
+            hash: hashEvidence(projects),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: "argocd/projects",
+            status: projects.items?.length > 0 ? "compliant" : "non_compliant",
+            data: { projectCount: projects.items?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/ArtifactoryConnector.d.ts

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

@@ -0,0 +1,94 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "artifactory-repos",
+        name: "Repository Management",
+        description: "Fetch repository types, permissions, and replication settings",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "artifactory-artifacts",
+        name: "Artifact Security",
+        description: "Fetch artifact scan results and checksum verification",
+        evidenceCategories: ["data_protection", "vulnerability_management"],
+    },
+    {
+        id: "artifactory-audit",
+        name: "Access Audit",
+        description: "Fetch artifact access logs and user activity",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+    {
+        id: "artifactory-licenses",
+        name: "License Compliance",
+        description: "Fetch license policy violations and component analysis",
+        evidenceCategories: ["compliance", "vulnerability_management"],
+    },
+];
+export class ArtifactoryConnector {
+    id = "artifactory";
+    name = "JFrog Artifactory";
+    category = "ci_cd";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "PCI_DSS",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://artifactory.example.com";
+        const resp = await fetch(`${base}/artifactory/api${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Artifactory API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/system/ping");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const repos = await this.fetchApi(config, "/repositories?type=local").catch(() => []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "artifactory-repos",
+            timestamp: now,
+            hash: hashEvidence(Array.isArray(repos) ? { count: repos.length } : repos),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "artifactory/repositories",
+            status: Array.isArray(repos) && repos.length > 0 ? "compliant" : "unknown",
+            data: { repositoryCount: Array.isArray(repos) ? repos.length : 0 },
+            metadata: {},
+        });
+        const storage = await this.fetchApi(config, "/storage").catch(() => ({}));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "artifactory-artifacts",
+            timestamp: now,
+            hash: hashEvidence(storage),
+            framework: "ISO27001",
+            controlId: "A.8.3.1",
+            source: "artifactory/storage",
+            status: "partial",
+            data: storage,
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/AtlassianJiraConnector.d.ts

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

@@ -0,0 +1,134 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "jira-projects",
+        name: "Project Configuration",
+        description: "Fetch project settings, schemes, and workflow configurations",
+        evidenceCategories: ["configuration", "access_control"],
+    },
+    {
+        id: "jira-permissions",
+        name: "Permission Schemes",
+        description: "Fetch permission schemes and role assignments",
+        evidenceCategories: ["access_control"],
+    },
+    {
+        id: "jira-audit-log",
+        name: "Audit Log",
+        description: "Fetch audit trail of administrative and issue changes",
+        evidenceCategories: ["audit", "change_management"],
+    },
+    {
+        id: "jira-security-issues",
+        name: "Security Issue Tracking",
+        description: "Fetch security-labeled issues and SLA compliance",
+        evidenceCategories: ["vulnerability_management", "incident_management"],
+    },
+];
+export class AtlassianJiraConnector {
+    id = "atlassian_jira";
+    name = "Atlassian Jira";
+    category = "project_management";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://your-domain.atlassian.net";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                Accept: "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Jira API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/rest/api/3/myself");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const projectKey = config.extra?.projectKey || "SEC";
+        const myself = await this.fetchApi(config, "/rest/api/3/myself");
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "jira-projects",
+            timestamp: now,
+            hash: hashEvidence(myself),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: `jira/${projectKey}/projects`,
+            status: "compliant",
+            data: {
+                user: myself.emailAddress,
+                locale: myself.locale,
+                active: myself.active,
+            },
+            metadata: { projectKey },
+        });
+        const permissions = await this.fetchApi(config, `/rest/api/3/permissionscheme`).catch(() => ({ values: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "jira-permissions",
+            timestamp: now,
+            hash: hashEvidence(permissions),
+            framework: "SOC2",
+            controlId: "CC6.3",
+            source: `jira/${projectKey}/permissions`,
+            status: Array.isArray(permissions.values) && permissions.values.length > 0
+                ? "compliant"
+                : "partial",
+            data: { schemeCount: Array.isArray(permissions.values) ? permissions.values.length : 0 },
+            metadata: { projectKey },
+        });
+        const auditLog = await this.fetchApi(config, `/rest/api/3/audit/record?limit=20`).catch(() => ({ records: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "jira-audit-log",
+            timestamp: now,
+            hash: hashEvidence(auditLog),
+            framework: "ISO27001",
+            controlId: "A.12.4.1",
+            source: `jira/${projectKey}/audit`,
+            status: Array.isArray(auditLog.records) && auditLog.records.length > 0
+                ? "compliant"
+                : "partial",
+            data: { recordCount: Array.isArray(auditLog.records) ? auditLog.records.length : 0 },
+            metadata: { projectKey },
+        });
+        const securityIssues = await this.fetchApi(config, `/rest/api/3/search?jql=project=${projectKey}%20AND%20labels=security&maxResults=10`).catch(() => ({ issues: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "jira-security-issues",
+            timestamp: now,
+            hash: hashEvidence(securityIssues),
+            framework: "NIST_CSF",
+            controlId: "RS.AN",
+            source: `jira/${projectKey}/security-issues`,
+            status: Array.isArray(securityIssues.issues)
+                ? securityIssues.issues.length === 0
+                    ? "compliant"
+                    : "non_compliant"
+                : "unknown",
+            data: { openSecurityIssues: Array.isArray(securityIssues.issues) ? securityIssues.issues.length : 0 },
+            metadata: { projectKey },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/Auth0Connector.d.ts

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

@@ -0,0 +1,150 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "auth0-users",
+        name: "User Accounts",
+        description: "Fetch Auth0 user accounts, email verification, and MFA enrollment status",
+        evidenceCategories: ["identity_management", "authentication"],
+    },
+    {
+        id: "auth0-applications",
+        name: "Applications",
+        description: "Fetch registered applications and their OAuth/OIDC configurations",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "auth0-connections",
+        name: "Connections",
+        description: "Fetch identity provider connections and their configurations",
+        evidenceCategories: ["identity_management", "configuration"],
+    },
+    {
+        id: "auth0-attack-protection",
+        name: "Attack Protection",
+        description: "Fetch Auth0 attack protection settings (brute force, suspicious IP, etc.)",
+        evidenceCategories: ["security_controls", "threat_protection"],
+    },
+    {
+        id: "auth0-roles",
+        name: "Roles & Permissions",
+        description: "Fetch assigned roles, permissions, and API authorizations",
+        evidenceCategories: ["access_control", "authorization"],
+    },
+];
+export class Auth0Connector {
+    id = "auth0";
+    name = "Auth0";
+    category = "identity";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "HIPAA", "PCI_DSS"];
+    async fetchApi(config, endpoint) {
+        const domain = config.extra?.domain || config.baseUrl || "";
+        const base = domain.startsWith("http") ? domain : `https://${domain}`;
+        const resp = await fetch(`${base}/api/v2${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                Accept: "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Auth0 API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/users?per_page=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const users = await this.fetchApi(config, "/users?per_page=100&include_totals=true").catch(() => ({ users: [], total: 0 }));
+        const userList = (users.users || []);
+        const mfaEnabled = userList.filter((u) => {
+            const factors = (u.multifactor || []);
+            return factors.length > 0;
+        });
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "auth0-users",
+            timestamp: now,
+            hash: hashEvidence({ total: userList.length, mfaEnabled: mfaEnabled.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "auth0/users",
+            status: mfaEnabled.length > userList.length * 0.8 ? "compliant" : "partial",
+            data: {
+                userCount: userList.length,
+                mfaEnabledCount: mfaEnabled.length,
+                total: users.total,
+            },
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        const apps = await this.fetchApi(config, "/clients?is_global=false&fields=name,app_type,callbacks").catch(() => ({ clients: [] }));
+        const appList = (apps.clients || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "auth0-applications",
+            timestamp: now,
+            hash: hashEvidence({ appCount: appList.length }),
+            framework: "ISO27001",
+            controlId: "A.14.2.5",
+            source: "auth0/clients",
+            status: "unknown",
+            data: { appCount: appList.length },
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        const connections = await this.fetchApi(config, "/connections?strategy=auth0,discord,facebook,google-oauth2,linkedin,samlp,oidc").catch(() => ({ connections: [] }));
+        const connList = (connections.connections || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "auth0-connections",
+            timestamp: now,
+            hash: hashEvidence({ connectionCount: connList.length }),
+            framework: "SOC2",
+            controlId: "CC6.2",
+            source: "auth0/connections",
+            status: "unknown",
+            data: { connectionCount: connList.length },
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        const attackProtection = await this.fetchApi(config, "/attack-protection").catch(() => ({}));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "auth0-attack-protection",
+            timestamp: now,
+            hash: hashEvidence(attackProtection),
+            framework: "NIST_CSF",
+            controlId: "PR.AC-1",
+            source: "auth0/attack-protection",
+            status: "unknown",
+            data: { attackProtection },
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        const roles = await this.fetchApi(config, "/roles").catch(() => ({ roles: [] }));
+        const roleList = (roles.roles || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "auth0-roles",
+            timestamp: now,
+            hash: hashEvidence({ roleCount: roleList.length }),
+            framework: "ISO27001",
+            controlId: "A.9.2.3",
+            source: "auth0/roles",
+            status: "unknown",
+            data: { roleCount: roleList.length },
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/AzureADConnector.d.ts

@@ -0,0 +1,12 @@
+import type { IntegrationConnector, ConnectorConfig, EvidenceArtifact, IntegrationCapability, ComplianceFramework } from "../types.js";
+export declare class AzureADConnector implements IntegrationConnector {
+    readonly id = "azure-ad";
+    readonly name = "Azure Active Directory";
+    readonly category: "identity";
+    readonly authType: "oauth2";
+    readonly capabilities: IntegrationCapability[];
+    readonly frameworks: ComplianceFramework[];
+    private getAccessToken;
+    testConnection(config: ConnectorConfig): Promise<boolean>;
+    collectEvidence(config: ConnectorConfig): Promise<EvidenceArtifact[]>;
+}