@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/AWSGuardDutyConnector.js

@@ -0,0 +1,139 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "gd-findings",
+        name: "GuardDuty Findings",
+        description: "Fetch active and high-severity GuardDuty findings",
+        evidenceCategories: ["vulnerability_management", "threat_detection"],
+    },
+    {
+        id: "gd-detector-status",
+        name: "Detector Status",
+        description: "Fetch GuardDuty detector configuration and publishing destination",
+        evidenceCategories: ["configuration", "monitoring"],
+    },
+    {
+        id: "gd-ip-reputation",
+        name: "IP Reputation Findings",
+        description: "Fetch IP reputation threat intelligence findings",
+        evidenceCategories: ["threat_detection", "network_security"],
+    },
+    {
+        id: "gd-s3-protection",
+        name: "S3 Protection Findings",
+        description: "Fetch S3 data event-based GuardDuty findings",
+        evidenceCategories: ["data_protection", "vulnerability_management"],
+    },
+];
+export class AWSGuardDutyConnector {
+    id = "aws_guardduty";
+    name = "AWS GuardDuty";
+    category = "cloud_provider";
+    authType = "service_account";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "PCI_DSS",
+        "HIPAA",
+    ];
+    async signRequest(config, service, region, method, path) {
+        const host = `${service}.${region}.amazonaws.com`;
+        const resp = await fetch(`https://${host}${path}`, {
+            headers: {
+                Authorization: `AWS4-HMAC-SHA256 Credential=${config.apiToken}/${region}/${service}/aws4_request`,
+                "X-Amz-Date": new Date().toISOString().replace(/[:\-]|\.\d{3}/g, ""),
+                Host: host,
+            },
+            method,
+        });
+        if (!resp.ok)
+            throw new Error(`AWS API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            const region = config.region || "us-east-1";
+            await this.signRequest(config, "guardduty", region, "GET", "/detectors");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const region = config.region || "us-east-1";
+        const detectorId = config.extra?.detectorId || "default";
+        const detectors = await this.signRequest(config, "guardduty", region, "GET", "/detectors").catch(() => ({ detectorIds: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gd-detector-status",
+            timestamp: now,
+            hash: hashEvidence(detectors),
+            framework: "SOC2",
+            controlId: "CC7.1",
+            source: `aws/guardduty/${region}/detectors`,
+            status: Array.isArray(detectors.detectorIds) && detectors.detectorIds.length > 0
+                ? "compliant"
+                : "non_compliant",
+            data: { activeDetectors: Array.isArray(detectors.detectorIds) ? detectors.detectorIds.length : 0 },
+            metadata: { region, detectorId },
+        });
+        const findings = await this.signRequest(config, "guardduty", region, "POST", `/detectors/${detectorId}/findings`).catch(() => ({ findings: [] }));
+        const findingList = Array.isArray(findings.findings) ? findings.findings : [];
+        const highSeverity = findingList.filter((f) => f.severity >= 7);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gd-findings",
+            timestamp: now,
+            hash: hashEvidence(findings),
+            framework: "NIST_CSF",
+            controlId: "RS.AN",
+            source: `aws/guardduty/${region}/findings`,
+            status: highSeverity.length === 0 ? "compliant" : "non_compliant",
+            data: {
+                totalFindings: findingList.length,
+                highSeverityCount: highSeverity.length,
+            },
+            metadata: { region, detectorId },
+        });
+        const ipFindings = await this.signRequest(config, "guardduty", region, "POST", `/detectors/${detectorId}/findings?FilterCriteria={"Criterion":{"type":[{"Value":"Recon:EC2/API calls made from unusual location","Comparison":"eq"}]}}`).catch(() => ({ findings: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gd-ip-reputation",
+            timestamp: now,
+            hash: hashEvidence(ipFindings),
+            framework: "ISO27001",
+            controlId: "A.13.1.1",
+            source: `aws/guardduty/${region}/ip-reputation`,
+            status: Array.isArray(ipFindings.findings) && ipFindings.findings.length === 0
+                ? "compliant"
+                : "non_compliant",
+            data: { ipReputationFindings: Array.isArray(ipFindings.findings) ? ipFindings.findings.length : 0 },
+            metadata: { region, detectorId },
+        });
+        const s3Findings = await this.signRequest(config, "guardduty", region, "POST", `/detectors/${detectorId}/findings?FilterCriteria={"Criterion":{"resource.accessKeyDetails.userName":[{"Value":"*","Comparison":"contains"}]}}`).catch(() => ({ findings: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "gd-s3-protection",
+            timestamp: now,
+            hash: hashEvidence(s3Findings),
+            framework: "PCI_DSS",
+            controlId: "3.4.1",
+            source: `aws/guardduty/${region}/s3-protection`,
+            status: Array.isArray(s3Findings.findings) && s3Findings.findings.length === 0
+                ? "compliant"
+                : "non_compliant",
+            data: { s3Findings: Array.isArray(s3Findings.findings) ? s3Findings.findings.length : 0 },
+            metadata: { region, detectorId },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/AWSIAMConnector.d.ts

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

package/dist/connectors/AWSIAMConnector.js

@@ -0,0 +1,90 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "aws-iam-policies",
+        name: "IAM Policies",
+        description: "Fetch IAM policies, attached managed policies, and inline policies",
+        evidenceCategories: ["access_control"],
+    },
+    {
+        id: "aws-iam-access-analyzer",
+        name: "IAM Access Analyzer",
+        description: "Fetch Access Analyzer findings for cross-account and external access",
+        evidenceCategories: ["access_control", "risk_management"],
+    },
+];
+export class AWSIAMConnector {
+    id = "aws-iam";
+    name = "AWS IAM";
+    category = "cloud_provider";
+    authType = "service_account";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "HIPAA",
+        "PCI_DSS",
+    ];
+    async fetchAws(config, service, action, params = {}) {
+        const region = config.region || "us-east-1";
+        const host = `${service}.${region}.amazonaws.com`;
+        const query = new URLSearchParams({ Action: action, Version: "2010-05-08", ...params });
+        const resp = await fetch(`https://${host}/?${query}`, {
+            headers: {
+                Authorization: `AWS4-HMAC-SHA256 Credential=${config.apiToken}/${region}/${service}/aws4_request`,
+                "X-Amz-Date": new Date().toISOString().replace(/[:-]|\.\d{3}/g, ""),
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`AWS ${service} ${resp.status}: ${resp.statusText}`);
+        const text = await resp.text();
+        return { raw: text };
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchAws(config, "iam", "GetCallerIdentity");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const policies = await this.fetchAws(config, "iam", "ListPolicies", {
+            Scope: "Local",
+        }).catch(() => ({ policies: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "aws-iam-policies",
+            timestamp: now,
+            hash: hashEvidence(policies),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "aws-iam/ListPolicies",
+            status: "unknown",
+            data: { policies },
+            metadata: { region: config.region || "us-east-1" },
+        });
+        const analyzer = await this.fetchAws(config, "accessanalyzer", "ListFindings", {
+            analyzerArn: config.extra?.analyzerArn || "",
+        }).catch(() => ({ findings: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "aws-iam-access-analyzer",
+            timestamp: now,
+            hash: hashEvidence(analyzer),
+            framework: "SOC2",
+            controlId: "CC6.2",
+            source: "aws-access-analyzer/ListFindings",
+            status: "unknown",
+            data: { findings: analyzer },
+            metadata: { region: config.region || "us-east-1" },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/AWSKMSConnector.d.ts

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

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "awskms-keys",
+        name: "KMS Keys",
+        description: "Fetch KMS key configurations, rotation policies, and usage",
+        evidenceCategories: ["encryption", "configuration"],
+    },
+    {
+        id: "awskms-access",
+        name: "Key Access Controls",
+        description: "Fetch key policies and grants controlling access to KMS keys",
+        evidenceCategories: ["access_control", "encryption"],
+    },
+    {
+        id: "awskms-audit",
+        name: "Key Audit Trail",
+        description: "Fetch CloudTrail events for KMS key usage and management",
+        evidenceCategories: ["monitoring", "audit"],
+    },
+];
+export class AWSKMSConnector {
+    id = "aws-kms";
+    name = "AWS KMS";
+    category = "cloud_provider";
+    authType = "service_account";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "PCI_DSS", "HIPAA"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://kms.us-east-1.amazonaws.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`AWS KMS API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/?Action=ListKeys&Limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const keys = await this.fetchApi(config, "/?Action=ListKeys").catch(() => ({ Keys: [] }));
+        const keyList = (keys.Keys || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "awskms-keys",
+            timestamp: now,
+            hash: hashEvidence({ keyCount: keyList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "aws-kms/keys",
+            status: keyList.length > 0 ? "compliant" : "unknown",
+            data: { keyCount: keyList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/AWSLambdaConnector.d.ts

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

@@ -0,0 +1,84 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "awslambda-functions",
+        name: "Lambda Functions",
+        description: "Fetch AWS Lambda function configurations and runtime settings",
+        evidenceCategories: ["cloud_configuration", "access_control"],
+    },
+    {
+        id: "awslambda-permissions",
+        name: "Function Permissions",
+        description: "Fetch IAM execution roles and resource policies on Lambda functions",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "awslambda-logging",
+        name: "Function Logging",
+        description: "Fetch CloudWatch log group configurations for Lambda functions",
+        evidenceCategories: ["monitoring", "configuration"],
+    },
+];
+export class AWSLambdaConnector {
+    id = "aws-lambda";
+    name = "AWS Lambda";
+    category = "cloud_provider";
+    authType = "service_account";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "PCI_DSS", "HIPAA"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://lambda.us-east-1.amazonaws.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`AWS Lambda API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/2015-03-31/functions/?MaxItems=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const functions = await this.fetchApi(config, "/2015-03-31/functions/?MaxItems=100").catch(() => ({ Functions: [] }));
+        const funcList = (functions.Functions || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "awslambda-functions",
+            timestamp: now,
+            hash: hashEvidence({ functionCount: funcList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "aws-lambda/functions",
+            status: funcList.length > 0 ? "compliant" : "unknown",
+            data: { functionCount: funcList.length },
+            metadata: {},
+        });
+        const publicFunctions = funcList.filter((f) => f.Policy !== null);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "awslambda-permissions",
+            timestamp: now,
+            hash: hashEvidence({ publicCount: publicFunctions.length }),
+            framework: "SOC2",
+            controlId: "CC6.3",
+            source: "aws-lambda/permissions",
+            status: publicFunctions.length === 0 ? "compliant" : "non_compliant",
+            data: { publicFunctionCount: publicFunctions.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/AWSRDSConnector.d.ts

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

@@ -0,0 +1,84 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "awsrds-instances",
+        name: "RDS Instances",
+        description: "Fetch RDS instance configurations, engine versions, and backup settings",
+        evidenceCategories: ["cloud_configuration", "data_protection"],
+    },
+    {
+        id: "awsrds-security",
+        name: "Security Groups",
+        description: "Fetch VPC security groups and IAM authentication settings for RDS",
+        evidenceCategories: ["access_control", "network_security"],
+    },
+    {
+        id: "awsrds-encryption",
+        name: "Encryption at Rest",
+        description: "Fetch KMS encryption configurations for RDS instances and snapshots",
+        evidenceCategories: ["data_protection", "encryption"],
+    },
+];
+export class AWSRDSConnector {
+    id = "aws-rds";
+    name = "AWS RDS";
+    category = "cloud_provider";
+    authType = "service_account";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "PCI_DSS", "HIPAA"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://rds.us-east-1.amazonaws.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`AWS RDS API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/?Action=DescribeDBInstances&MaxRecords=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const instances = await this.fetchApi(config, "/?Action=DescribeDBInstances").catch(() => ({ DBInstances: [] }));
+        const dbList = (instances.DBInstances || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "awsrds-instances",
+            timestamp: now,
+            hash: hashEvidence({ instanceCount: dbList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "aws-rds/instances",
+            status: dbList.length > 0 ? "compliant" : "unknown",
+            data: { instanceCount: dbList.length },
+            metadata: {},
+        });
+        const unencrypted = dbList.filter((i) => !i.StorageEncrypted);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "awsrds-encryption",
+            timestamp: now,
+            hash: hashEvidence({ unencryptedCount: unencrypted.length }),
+            framework: "PCI_DSS",
+            controlId: "3.4",
+            source: "aws-rds/encryption",
+            status: unencrypted.length === 0 ? "compliant" : "non_compliant",
+            data: { unencryptedCount: unencrypted.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/AWSS3Connector.d.ts

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

package/dist/connectors/AWSS3Connector.js

@@ -0,0 +1,112 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "s3-encryption",
+        name: "Bucket Encryption",
+        description: "Fetch S3 bucket default encryption configuration",
+        evidenceCategories: ["encryption"],
+    },
+    {
+        id: "s3-versioning",
+        name: "Bucket Versioning",
+        description: "Fetch S3 bucket versioning status",
+        evidenceCategories: ["data_protection"],
+    },
+    {
+        id: "s3-logging",
+        name: "Bucket Access Logging",
+        description: "Fetch S3 bucket server access logging configuration",
+        evidenceCategories: ["logging"],
+    },
+];
+export class AWSS3Connector {
+    id = "aws-s3";
+    name = "AWS S3";
+    category = "cloud_provider";
+    authType = "service_account";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "HIPAA",
+        "PCI_DSS",
+    ];
+    async fetchS3(config, bucket, action) {
+        const region = config.region || "us-east-1";
+        const resp = await fetch(`https://${bucket}.s3.${region}.amazonaws.com/?${action}`, {
+            headers: {
+                Authorization: `AWS4-HMAC-SHA256 Credential=${config.apiToken}/${region}/s3/aws4_request`,
+                "X-Amz-Date": new Date().toISOString().replace(/[:-]|\.\d{3}/g, ""),
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`S3 ${action} failed: ${resp.status}`);
+        const text = await resp.text();
+        return { raw: text };
+    }
+    async testConnection(config) {
+        try {
+            const bucket = config.extra?.bucket || "test-bucket";
+            await this.fetchS3(config, bucket, "list-type=2&max-keys=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const bucket = config.extra?.bucket || "main-bucket";
+        const encryption = await this.fetchS3(config, bucket, "encryption").catch(() => ({
+            enabled: false,
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "s3-encryption",
+            timestamp: now,
+            hash: hashEvidence(encryption),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: `s3://${bucket}/encryption`,
+            status: encryption.enabled !== false ? "compliant" : "non_compliant",
+            data: { bucket, encryption },
+            metadata: { region: config.region || "us-east-1" },
+        });
+        const versioning = await this.fetchS3(config, bucket, "versioning").catch(() => ({
+            status: "Suspended",
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "s3-versioning",
+            timestamp: now,
+            hash: hashEvidence(versioning),
+            framework: "ISO27001",
+            controlId: "A.12.3.1",
+            source: `s3://${bucket}/versioning`,
+            status: versioning.status === "Enabled" ? "compliant" : "non_compliant",
+            data: { bucket, versioning },
+            metadata: { region: config.region || "us-east-1" },
+        });
+        const logging = await this.fetchS3(config, bucket, "logging").catch(() => ({
+            enabled: false,
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "s3-logging",
+            timestamp: now,
+            hash: hashEvidence(logging),
+            framework: "SOC2",
+            controlId: "CC7.1",
+            source: `s3://${bucket}/logging`,
+            status: logging.enabled !== false ? "compliant" : "non_compliant",
+            data: { bucket, logging },
+            metadata: { region: config.region || "us-east-1" },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/AkamaiConnector.d.ts

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