@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/SnykConnector.js

@@ -0,0 +1,84 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "snyk-vulns",
+        name: "Vulnerabilities",
+        description: "Fetch Snyk project vulnerabilities by severity",
+        evidenceCategories: ["vulnerability_management", "application_security"],
+    },
+    {
+        id: "snyk-license",
+        name: "License Compliance",
+        description: "Fetch open-source license compliance issues",
+        evidenceCategories: ["license_compliance", "supply_chain"],
+    },
+];
+export class SnykConnector {
+    id = "snyk";
+    name = "Snyk";
+    category = "vulnerability";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.snyk.io/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: { Authorization: `token ${config.apiToken}` },
+        });
+        if (!resp.ok)
+            throw new Error(`Snyk API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/user/me");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const orgId = config.extra?.orgId || "";
+        const projectId = config.extra?.projectId || "";
+        const issues = await this.fetchApi(config, `/orgs/${orgId}/projects/${projectId}/issues?severityThreshold=low`).catch(() => ({ issues: [] }));
+        const issueList = (issues.issues || []);
+        const bySeverity = {
+            critical: issueList.filter((i) => i.severity === "critical").length,
+            high: issueList.filter((i) => i.severity === "high").length,
+            medium: issueList.filter((i) => i.severity === "medium").length,
+            low: issueList.filter((i) => i.severity === "low").length,
+        };
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "snyk-vulns",
+            timestamp: now,
+            hash: hashEvidence({ issueCount: issueList.length, bySeverity }),
+            framework: "ISO27001",
+            controlId: "A.12.6.1",
+            source: `snyk/orgs/${orgId}/projects/${projectId}/issues`,
+            status: bySeverity.critical === 0 ? "compliant" : "non_compliant",
+            data: { totalIssues: issueList.length, bySeverity },
+            metadata: { orgId, projectId },
+        });
+        const licenses = await this.fetchApi(config, `/orgs/${orgId}/projects/${projectId}/issues?severityThreshold=low&types=license`).catch(() => ({ issues: [] }));
+        const licenseIssues = (licenses.issues || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "snyk-license",
+            timestamp: now,
+            hash: hashEvidence({ licenseIssueCount: licenseIssues.length }),
+            framework: "ISO27001",
+            controlId: "A.18.1.5",
+            source: `snyk/orgs/${orgId}/projects/${projectId}/licenses`,
+            status: licenseIssues.length === 0 ? "compliant" : "non_compliant",
+            data: { licenseIssues: licenseIssues.length },
+            metadata: { orgId, projectId },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/SnykMonitorConnector.d.ts

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

@@ -0,0 +1,131 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "snyk-vulns",
+        name: "Monitored Vulnerabilities",
+        description: "Fetch Snyk monitor vulnerability findings across projects",
+        evidenceCategories: ["vulnerability_management", "supply_chain"],
+    },
+    {
+        id: "snyk-licenses",
+        name: "License Compliance",
+        description: "Fetch license compliance results and policy violations",
+        evidenceCategories: ["compliance", "supply_chain"],
+    },
+    {
+        id: "snyk-issues",
+        name: "Open Issues",
+        description: "Fetch open Snyk issues with fix availability",
+        evidenceCategories: ["vulnerability_management", "change_management"],
+    },
+    {
+        id: "snyk-org",
+        name: "Organization Settings",
+        description: "Fetch Snyk org settings, RBAC, and integrations",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+];
+export class SnykMonitorConnector {
+    id = "snyk_monitor";
+    name = "Snyk Monitor";
+    category = "vulnerability";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "PCI_DSS",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.snyk.io/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `token ${config.apiToken}`,
+                Accept: "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Snyk API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/orgs");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const orgId = config.extra?.orgId || "default-org";
+        const projectId = config.extra?.projectId || "";
+        const issues = await this.fetchApi(config, `/orgs/${orgId}/issues?limit=100&severity=high,critical`).catch(() => ({ issues: [] }));
+        const issueList = Array.isArray(issues.issues) ? issues.issues : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "snyk-vulns",
+            timestamp: now,
+            hash: hashEvidence({ count: issueList.length }),
+            framework: "SOC2",
+            controlId: "CC6.6",
+            source: `snyk/${orgId}/vulnerabilities`,
+            status: issueList.length === 0 ? "compliant" : "non_compliant",
+            data: { highCriticalIssues: issueList.length },
+            metadata: { orgId },
+        });
+        const licenses = await this.fetchApi(config, `/orgs/${orgId}/licenses?limit=50`).catch(() => ({ licenses: [] }));
+        const licenseList = Array.isArray(licenses.licenses) ? licenses.licenses : [];
+        const deniedLicenses = licenseList.filter((l) => l.compatibility === "not_compatible");
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "snyk-licenses",
+            timestamp: now,
+            hash: hashEvidence({ count: licenseList.length, denied: deniedLicenses.length }),
+            framework: "ISO27001",
+            controlId: "A.12.1.1",
+            source: `snyk/${orgId}/licenses`,
+            status: deniedLicenses.length === 0 ? "compliant" : "non_compliant",
+            data: { totalLicenses: licenseList.length, denied: deniedLicenses.length },
+            metadata: { orgId },
+        });
+        const openIssues = projectId
+            ? await this.fetchApi(config, `/orgs/${orgId}/projects/${projectId}/issues?limit=50`).catch(() => ({ issues: [] }))
+            : { issues: [] };
+        const openList = Array.isArray(openIssues.issues) ? openIssues.issues : [];
+        const fixable = openList.filter((i) => i.fixable === true);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "snyk-issues",
+            timestamp: now,
+            hash: hashEvidence({ open: openList.length, fixable: fixable.length }),
+            framework: "NIST_CSF",
+            controlId: "ID.RA",
+            source: `snyk/${orgId}/issues`,
+            status: openList.length === 0 ? "compliant" : "non_compliant",
+            data: { openIssues: openList.length, fixableIssues: fixable.length },
+            metadata: { orgId },
+        });
+        const org = await this.fetchApi(config, `/orgs/${orgId}`).catch(() => ({}));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "snyk-org",
+            timestamp: now,
+            hash: hashEvidence(org),
+            framework: "PCI_DSS",
+            controlId: "7.2.1",
+            source: `snyk/${orgId}/settings`,
+            status: "compliant",
+            data: org,
+            metadata: { orgId },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/SophosConnector.d.ts

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

@@ -0,0 +1,87 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "sophos-endpoints",
+        name: "Endpoint Protection",
+        description: "Fetch Sophos endpoint agent status and managed status",
+        evidenceCategories: ["endpoint_security", "monitoring"],
+    },
+    {
+        id: "sophos-threats",
+        name: "Threat Detections",
+        description: "Fetch threat detection events and incident summaries",
+        evidenceCategories: ["vulnerability_management", "monitoring"],
+    },
+    {
+        id: "sophos-policies",
+        name: "Security Policies",
+        description: "Fetch Sophos security policy configurations and compliance state",
+        evidenceCategories: ["policy_compliance", "configuration"],
+    },
+];
+export class SophosConnector {
+    id = "sophos";
+    name = "Sophos";
+    category = "endpoint";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "HIPAA"];
+    async fetchApi(config, endpoint) {
+        const tenantId = config.tenantId || config.extra?.tenantId || "";
+        const base = config.baseUrl || `https://api-${tenantId}.central.sophos.com`;
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+                "X-Tenant-ID": tenantId,
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Sophos API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/endpoint/v1/endpoints?pageSize=1");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const endpoints = await this.fetchApi(config, "/endpoint/v1/endpoints?pageSize=100").catch(() => ({ items: [] }));
+        const endpointList = (endpoints.items || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "sophos-endpoints",
+            timestamp: now,
+            hash: hashEvidence({ endpointCount: endpointList.length }),
+            framework: "SOC2",
+            controlId: "CC6.8",
+            source: "sophos/endpoints",
+            status: endpointList.length > 0 ? "compliant" : "unknown",
+            data: { endpointCount: endpointList.length },
+            metadata: {},
+        });
+        const detections = await this.fetchApi(config, "/detector/v2/detections?pageSize=10").catch(() => ({ items: [] }));
+        const detectList = (detections.items || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "sophos-threats",
+            timestamp: now,
+            hash: hashEvidence({ detectionCount: detectList.length }),
+            framework: "ISO27001",
+            controlId: "A.12.2.1",
+            source: "sophos/detections",
+            status: detectList.length === 0 ? "compliant" : "non_compliant",
+            data: { recentDetections: detectList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/SpinnakerConnector.d.ts

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

@@ -0,0 +1,70 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "spinnaker-pipelines",
+        name: "Deployment Pipelines",
+        description: "Fetch Spinnaker pipeline configurations and execution history",
+        evidenceCategories: ["ci_cd", "change_management"],
+    },
+    {
+        id: "spinnaker-applications",
+        name: "Applications",
+        description: "Fetch Spinnaker application definitions and cluster configurations",
+        evidenceCategories: ["cloud_configuration", "change_management"],
+    },
+    {
+        id: "spinnaker-rollback",
+        name: "Rollback Policies",
+        description: "Fetch automatic rollback configurations and canary analysis",
+        evidenceCategories: ["disaster_recovery", "configuration"],
+    },
+];
+export class SpinnakerConnector {
+    id = "spinnaker";
+    name = "Spinnaker";
+    category = "ci_cd";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://spinnaker.example.com";
+        const resp = await fetch(`${base}/gate${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Spinnaker API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/applications?expand=false");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const apps = await this.fetchApi(config, "/applications?expand=false").catch(() => []);
+        const appList = Array.isArray(apps) ? apps : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "spinnaker-applications",
+            timestamp: now,
+            hash: hashEvidence({ appCount: appList.length }),
+            framework: "SOC2",
+            controlId: "CC8.1",
+            source: "spinnaker/applications",
+            status: "unknown",
+            data: { applicationCount: appList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/SplunkConnector.d.ts

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

package/dist/connectors/SplunkConnector.js

@@ -0,0 +1,126 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "splunk-indexes",
+        name: "Index Overview",
+        description: "Fetch Splunk index configurations and data volumes",
+        evidenceCategories: ["log_management", "configuration"],
+    },
+    {
+        id: "splunk-saved-searches",
+        name: "Saved Searches & Alerts",
+        description: "Fetch saved searches, alerts, and correlation rules",
+        evidenceCategories: ["monitoring", "alerting"],
+    },
+    {
+        id: "splunk-sourcetypes",
+        name: "Source Types",
+        description: "Fetch ingested source types and event volumes",
+        evidenceCategories: ["log_management", "data_collection"],
+    },
+    {
+        id: "splunk-users",
+        name: "User Accounts",
+        description: "Fetch Splunk user accounts and role assignments",
+        evidenceCategories: ["access_control", "identity_management"],
+    },
+];
+export class SplunkConnector {
+    id = "splunk";
+    name = "Splunk";
+    category = "siem";
+    authType = "basic_auth";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF", "HIPAA", "PCI_DSS"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || `https://${config.extra?.host || "localhost"}:8089`;
+        const auth = Buffer.from(`${config.clientId || ""}:${config.clientSecret || ""}`).toString("base64");
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Accept: "application/json",
+                Authorization: `Basic ${auth}`,
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Splunk API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/services/server/info?output_mode=json");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const indexes = await this.fetchApi(config, "/services/data/indexes?output_mode=json&count=0").catch(() => ({ entry: [] }));
+        const indexList = (indexes.entry || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "splunk-indexes",
+            timestamp: now,
+            hash: hashEvidence({ indexCount: indexList.length }),
+            framework: "SOC2",
+            controlId: "CC7.2",
+            source: "splunk/indexes",
+            status: indexList.length > 0 ? "compliant" : "non_compliant",
+            data: { indexCount: indexList.length },
+            metadata: { host: config.extra?.host || "" },
+        });
+        const searches = await this.fetchApi(config, "/services/saved/searches?output_mode=json&count=0").catch(() => ({ entry: [] }));
+        const searchList = (searches.entry || []);
+        const alerts = searchList.filter((s) => {
+            const cont = (s.content || {});
+            return cont.alert === 1 || cont.alert === true;
+        });
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "splunk-saved-searches",
+            timestamp: now,
+            hash: hashEvidence({ total: searchList.length, alerts: alerts.length }),
+            framework: "ISO27001",
+            controlId: "A.12.4.1",
+            source: "splunk/saved/searches",
+            status: "unknown",
+            data: { searchCount: searchList.length, alertCount: alerts.length },
+            metadata: { host: config.extra?.host || "" },
+        });
+        const sourcetypes = await this.fetchApi(config, "/services/data/indexes-extended?output_mode=json&count=0").catch(() => ({ entry: [] }));
+        const stList = (sourcetypes.entry || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "splunk-sourcetypes",
+            timestamp: now,
+            hash: hashEvidence({ sourcetypeCount: stList.length }),
+            framework: "SOC2",
+            controlId: "CC7.2",
+            source: "splunk/indexes-extended",
+            status: "unknown",
+            data: { sourcetypeCount: stList.length },
+            metadata: { host: config.extra?.host || "" },
+        });
+        const users = await this.fetchApi(config, "/services/admin/users?output_mode=json&count=0").catch(() => ({ entry: [] }));
+        const userList = (users.entry || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "splunk-users",
+            timestamp: now,
+            hash: hashEvidence({ userCount: userList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "splunk/admin/users",
+            status: "unknown",
+            data: { userCount: userList.length },
+            metadata: { host: config.extra?.host || "" },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/StripeConnector.d.ts

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

@@ -0,0 +1,97 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "stripe-payments",
+        name: "Payment Processing",
+        description: "Fetch Stripe payment configurations and PCI compliance status",
+        evidenceCategories: ["compliance", "data_protection"],
+    },
+    {
+        id: "stripe-webhooks",
+        name: "Webhook Security",
+        description: "Fetch webhook endpoint configurations and signature verification",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "stripe-api-keys",
+        name: "API Key Management",
+        description: "Fetch API key usage and rotation status",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "stripe-disputes",
+        name: "Fraud Prevention",
+        description: "Fetch Radar rules and dispute/fraud metrics",
+        evidenceCategories: ["vulnerability_management", "monitoring"],
+    },
+];
+export class StripeConnector {
+    id = "stripe";
+    name = "Stripe";
+    category = "finance";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "PCI_DSS",
+        "NIST_CSF",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://api.stripe.com";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Stripe API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/v1/balance");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const balance = await this.fetchApi(config, "/v1/balance").catch(() => ({}));
+        const balanceData = balance;
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "stripe-payments",
+            timestamp: now,
+            hash: hashEvidence(balance),
+            framework: "PCI_DSS",
+            controlId: "1.3",
+            source: "stripe/balance",
+            status: balanceData.object === "balance" ? "compliant" : "unknown",
+            data: { balanceAvailable: (balanceData.available || []).length },
+            metadata: {},
+        });
+        const webhooks = await this.fetchApi(config, "/v1/webhook_endpoints").catch(() => ({
+            data: [],
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "stripe-webhooks",
+            timestamp: now,
+            hash: hashEvidence(webhooks),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "stripe/webhooks",
+            status: webhooks.data?.length > 0 ? "compliant" : "unknown",
+            data: { webhookEndpoints: webhooks.data?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/TableauConnector.d.ts

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