@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/TravisCIConnector.d.ts

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

@@ -0,0 +1,95 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "travis-builds",
+        name: "Build History",
+        description: "Fetch Travis CI build configurations and results",
+        evidenceCategories: ["change_management", "configuration"],
+    },
+    {
+        id: "travis-env",
+        name: "Environment Variables",
+        description: "Fetch encrypted environment variable configurations",
+        evidenceCategories: ["data_protection", "access_control"],
+    },
+    {
+        id: "travis-repos",
+        name: "Repository Settings",
+        description: "Fetch enabled repositories and branch settings",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "travis-cron",
+        name: "Cron Jobs",
+        description: "Fetch scheduled build configurations",
+        evidenceCategories: ["change_management"],
+    },
+];
+export class TravisCIConnector {
+    id = "travis-ci";
+    name = "Travis CI";
+    category = "ci_cd";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.travis-ci.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Token ${config.apiToken}`,
+                "Travis-API-Version": "3",
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Travis CI API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/repos");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const repo = config.extra?.repo || "default/repo";
+        const builds = await this.fetchApi(config, `/repo/${repo.replace("/", "%2F")}/builds?limit=10`).catch(() => ({ builds: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "travis-builds",
+            timestamp: now,
+            hash: hashEvidence(builds),
+            framework: "SOC2",
+            controlId: "CC8.1",
+            source: `travis-ci.com/${repo}`,
+            status: "partial",
+            data: { recentBuilds: builds.builds?.length || 0 },
+            metadata: { repo },
+        });
+        const settings = await this.fetchApi(config, `/repo/${repo.replace("/", "%2F")}/settings`).catch(() => ({}));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "travis-repos",
+            timestamp: now,
+            hash: hashEvidence(settings),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: `travis-ci.com/${repo}/settings`,
+            status: "partial",
+            data: settings,
+            metadata: { repo },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/TrendMicroConnector.d.ts

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

@@ -0,0 +1,85 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "trendmicro-endpoints",
+        name: "Endpoint Protection",
+        description: "Fetch Trend Micro endpoint security agent status and policy compliance",
+        evidenceCategories: ["endpoint_security", "posture_assessment"],
+    },
+    {
+        id: "trendmicro-detections",
+        name: "Threat Detections",
+        description: "Fetch threat detection events and malware quarantine events",
+        evidenceCategories: ["vulnerability_management", "monitoring"],
+    },
+    {
+        id: "trendmicro-network",
+        name: "Network Inspection",
+        description: "Fetch network inspection rules and IPS/IDS event summaries",
+        evidenceCategories: ["network_security", "configuration"],
+    },
+];
+export class TrendMicroConnector {
+    id = "trendmicro";
+    name = "Trend Micro";
+    category = "endpoint";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "HIPAA"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://app.deepsecurity.trendmicro.com/api";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `ApiKey ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Trend Micro API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/computers?expand=none&maxComputerCount=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const computers = await this.fetchApi(config, "/computers?expand=none&maxComputerCount=100").catch(() => ({ computers: [] }));
+        const computerList = (computers.computers || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "trendmicro-endpoints",
+            timestamp: now,
+            hash: hashEvidence({ computerCount: computerList.length }),
+            framework: "SOC2",
+            controlId: "CC6.8",
+            source: "trendmicro/computers",
+            status: computerList.length > 0 ? "compliant" : "unknown",
+            data: { endpointCount: computerList.length },
+            metadata: {},
+        });
+        const events = await this.fetchApi(config, "/events?maxCount=10").catch(() => ({ events: [] }));
+        const eventList = (events.events || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "trendmicro-detections",
+            timestamp: now,
+            hash: hashEvidence({ eventCount: eventList.length }),
+            framework: "ISO27001",
+            controlId: "A.12.2.1",
+            source: "trendmicro/events",
+            status: eventList.length === 0 ? "compliant" : "non_compliant",
+            data: { recentEvents: eventList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/TwilioConnector.d.ts

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

package/dist/connectors/TwilioConnector.js

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "twilio-accounts",
+        name: "Account Configuration",
+        description: "Fetch Twilio account details, subaccount hierarchy, and usage records",
+        evidenceCategories: ["configuration", "monitoring"],
+    },
+    {
+        id: "twilio-security",
+        name: "Security Settings",
+        description: "Fetch Twilio API key management, IP restrictions, and webhook security",
+        evidenceCategories: ["access_control", "secret_management"],
+    },
+    {
+        id: "twilio-communications",
+        name: "Communication Logs",
+        description: "Fetch SMS/voice message delivery status and error logs",
+        evidenceCategories: ["monitoring", "audit"],
+    },
+];
+export class TwilioConnector {
+    id = "twilio";
+    name = "Twilio";
+    category = "communication";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "HIPAA"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.twilio.com/2010-04-01";
+        const auth = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString("base64");
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Basic ${auth}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Twilio API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/Accounts.json?Limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const account = await this.fetchApi(config, "/Account.json").catch(() => ({}));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "twilio-accounts",
+            timestamp: now,
+            hash: hashEvidence(account),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "twilio/account",
+            status: "unknown",
+            data: { connected: true },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/VercelConnector.d.ts

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

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "vercel-projects",
+        name: "Vercel Projects",
+        description: "Fetch Vercel project configurations, domains, and deployment settings",
+        evidenceCategories: ["cloud_configuration", "ci_cd"],
+    },
+    {
+        id: "vercel-deployments",
+        name: "Deployment History",
+        description: "Fetch recent deployment history, build logs, and rollback status",
+        evidenceCategories: ["ci_cd", "change_management"],
+    },
+    {
+        id: "vercel-security",
+        name: "Security Headers",
+        description: "Fetch Vercel security headers, CSP policies, and firewall rules",
+        evidenceCategories: ["network_security", "configuration"],
+    },
+];
+export class VercelConnector {
+    id = "vercel";
+    name = "Vercel";
+    category = "ci_cd";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.vercel.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Vercel API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/v9/projects?limit=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const projects = await this.fetchApi(config, "/v9/projects?limit=100").catch(() => ({ projects: [] }));
+        const projectList = (projects.projects || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "vercel-projects",
+            timestamp: now,
+            hash: hashEvidence({ projectCount: projectList.length }),
+            framework: "SOC2",
+            controlId: "CC8.1",
+            source: "vercel/projects",
+            status: "unknown",
+            data: { projectCount: projectList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/VultrConnector.d.ts

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

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "vultr-instances",
+        name: "Cloud Instances",
+        description: "Fetch Vultr compute instance configurations and status",
+        evidenceCategories: ["cloud_configuration", "infrastructure"],
+    },
+    {
+        id: "vultr-firewalls",
+        name: "Firewall Groups",
+        description: "Fetch firewall group rules and network access controls",
+        evidenceCategories: ["network_security", "access_control"],
+    },
+    {
+        id: "vultr-dns",
+        name: "DNS Domains",
+        description: "Fetch managed DNS domain configurations",
+        evidenceCategories: ["configuration", "infrastructure"],
+    },
+];
+export class VultrConnector {
+    id = "vultr";
+    name = "Vultr";
+    category = "cloud_provider";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.vultr.com/v2";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Vultr API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/accounts");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const instances = await this.fetchApi(config, "/instances").catch(() => ({ instances: [] }));
+        const instanceList = (instances.instances || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "vultr-instances",
+            timestamp: now,
+            hash: hashEvidence({ instanceCount: instanceList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "vultr/instances",
+            status: "unknown",
+            data: { instanceCount: instanceList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/WebexConnector.d.ts

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

package/dist/connectors/WebexConnector.js

@@ -0,0 +1,94 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "webex-meetings",
+        name: "Meeting Policies",
+        description: "Fetch Webex meeting security and lobby settings",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "webex-devices",
+        name: "Device Management",
+        description: "Fetch registered device compliance and firmware status",
+        evidenceCategories: ["endpoint", "configuration"],
+    },
+    {
+        id: "webex-users",
+        name: "User Provisioning",
+        description: "Fetch user accounts, roles, and license assignments",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "webex-audit",
+        name: "Admin Audit",
+        description: "Fetch admin activity and configuration change logs",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+];
+export class WebexConnector {
+    id = "webex";
+    name = "Cisco Webex";
+    category = "communication";
+    authType = "oauth2";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "HIPAA",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://webexapis.com/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Webex API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/people/me");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const people = await this.fetchApi(config, "/people?max=100").catch(() => ({ items: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "webex-users",
+            timestamp: now,
+            hash: hashEvidence(people),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "webex/people",
+            status: people.items?.length > 0 ? "compliant" : "unknown",
+            data: { userCount: people.items?.length || 0 },
+            metadata: {},
+        });
+        const devices = await this.fetchApi(config, "/devices").catch(() => ({ items: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "webex-devices",
+            timestamp: now,
+            hash: hashEvidence(devices),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: "webex/devices",
+            status: devices.items?.length > 0 ? "compliant" : "non_compliant",
+            data: { registeredDevices: devices.items?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/WizConnector.d.ts

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