@grc-claw/integration-marketplace 1.0.0

package/dist/connectors/SalesforceConnector.js

@@ -0,0 +1,91 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "sf-user-permissions",
+        name: "User Permissions",
+        description: "Fetch Salesforce user permission sets and profiles",
+        evidenceCategories: ["access_control", "authorization"],
+    },
+    {
+        id: "sf-field-security",
+        name: "Field-Level Security",
+        description: "Fetch field-level security configurations on sensitive objects",
+        evidenceCategories: ["data_protection", "access_control"],
+    },
+];
+export class SalesforceConnector {
+    id = "salesforce";
+    name = "Salesforce";
+    category = "hr";
+    authType = "oauth2";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "HIPAA"];
+    async getAccessToken(config) {
+        const resp = await fetch(`${config.baseUrl || "https://login.salesforce.com"}/services/oauth2/token`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                grant_type: "client_credentials",
+                client_id: config.clientId || "",
+                client_secret: config.clientSecret || "",
+            }),
+        });
+        if (!resp.ok)
+            throw new Error(`Salesforce token ${resp.status}`);
+        const data = (await resp.json());
+        return data.access_token;
+    }
+    async testConnection(config) {
+        try {
+            const token = await this.getAccessToken(config);
+            const instanceUrl = config.extra?.instanceUrl || "https://your-instance.salesforce.com";
+            const resp = await fetch(`${instanceUrl}/services/data/v59.0/limits`, {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            return resp.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const token = await this.getAccessToken(config);
+        const instanceUrl = config.extra?.instanceUrl || "https://your-instance.salesforce.com";
+        const headers = { Authorization: `Bearer ${token}` };
+        const users = await fetch(`${instanceUrl}/services/data/v59.0/query?q=SELECT+Id,Username,ProfileId,IsActive+FROM+User+WHERE+IsActive=TRUE+LIMIT+200`, { headers }).then((r) => r.json());
+        const userList = (users.records || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "sf-user-permissions",
+            timestamp: now,
+            hash: hashEvidence({ userCount: userList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "salesforce/users",
+            status: "unknown",
+            data: { activeUserCount: userList.length },
+            metadata: { instanceUrl },
+        });
+        const fieldPerms = await fetch(`${instanceUrl}/services/data/v59.0/query?q=SELECT+ParentId,Field,Editable+FROM+FieldPermission+WHERE+Parent.Profile.Name='Standard+User'+LIMIT+100`, { headers }).then((r) => r.json());
+        const permRecords = (fieldPerms.records || []);
+        const editableSensitive = permRecords.filter((p) => p.Editable === true &&
+            (p.Field || "").includes("Email"));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "sf-field-security",
+            timestamp: now,
+            hash: hashEvidence({ permissionCount: permRecords.length }),
+            framework: "ISO27001",
+            controlId: "A.9.4.1",
+            source: "salesforce/fieldPermissions",
+            status: editableSensitive.length === 0 ? "compliant" : "partial",
+            data: { fieldPermissionCount: permRecords.length, editableSensitiveFields: editableSensitive.length },
+            metadata: { instanceUrl },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/SlackConnector.d.ts

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

@@ -0,0 +1,109 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "slack-workspace",
+        name: "Workspace Settings",
+        description: "Fetch Slack workspace security and compliance settings",
+        evidenceCategories: ["configuration", "access_control"],
+    },
+    {
+        id: "slack-apps",
+        name: "App Installations",
+        description: "Fetch installed apps and their permissions",
+        evidenceCategories: ["access_control", "third_party_management"],
+    },
+    {
+        id: "slack-channels",
+        name: "Channel Access",
+        description: "Fetch channel privacy and access controls",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+];
+export class SlackConnector {
+    id = "slack";
+    name = "Slack";
+    category = "communication";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://slack.com/api";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: { Authorization: `Bearer ${config.apiToken}` },
+        });
+        if (!resp.ok)
+            throw new Error(`Slack API ${resp.status}: ${resp.statusText}`);
+        const data = (await resp.json());
+        if (data.ok === false)
+            throw new Error(`Slack error: ${data.error}`);
+        return data;
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/auth.test");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const team = await this.fetchApi(config, "/team.info");
+        const teamData = (team.team || {});
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "slack-workspace",
+            timestamp: now,
+            hash: hashEvidence(team),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "slack/team.info",
+            status: "compliant",
+            data: {
+                teamId: teamData.id,
+                teamName: teamData.name,
+                domain: teamData.domain,
+                emailDomain: teamData.email_domain,
+            },
+            metadata: { workspace: String(teamData.domain || "") },
+        });
+        const apps = await this.fetchApi(config, "/apps.permissions.list").catch(() => ({
+            scopes: [],
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "slack-apps",
+            timestamp: now,
+            hash: hashEvidence(apps),
+            framework: "ISO27001",
+            controlId: "A.14.2.5",
+            source: "slack/apps.permissions.list",
+            status: "unknown",
+            data: { appScopes: apps.scopes },
+            metadata: { workspace: String(teamData.domain || "") },
+        });
+        const channels = await this.fetchApi(config, "/conversations.list?types=public_channel,private_channel&limit=200").catch(() => ({
+            channels: [],
+        }));
+        const channelList = (channels.channels || []);
+        const privateChannels = channelList.filter((c) => c.is_private === true);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "slack-channels",
+            timestamp: now,
+            hash: hashEvidence({ total: channelList.length, private: privateChannels.length }),
+            framework: "SOC2",
+            controlId: "CC6.4",
+            source: "slack/conversations.list",
+            status: "unknown",
+            data: { totalChannels: channelList.length, privateChannels: privateChannels.length },
+            metadata: { workspace: String(teamData.domain || "") },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/SnowflakeConnector.d.ts

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

package/dist/connectors/SnowflakeConnector.js

@@ -0,0 +1,105 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "sf-access-policies",
+        name: "Access Policies",
+        description: "Fetch Snowflake access policies and role hierarchy",
+        evidenceCategories: ["access_control"],
+    },
+    {
+        id: "sf-query-history",
+        name: "Query History",
+        description: "Fetch query history for data access auditing",
+        evidenceCategories: ["audit", "data_access"],
+    },
+    {
+        id: "sf-data-access",
+        name: "Data Access Logs",
+        description: "Fetch COPY history and data loading access logs",
+        evidenceCategories: ["data_protection", "logging"],
+    },
+];
+export class SnowflakeConnector {
+    id = "snowflake";
+    name = "Snowflake";
+    category = "data_warehouse";
+    authType = "basic_auth";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "HIPAA"];
+    async querySnowflake(config, sql) {
+        const account = config.extra?.account || "your-account";
+        const resp = await fetch(`https://${account}.snowflakecomputing.com/api/v2/statements`, {
+            method: "POST",
+            headers: {
+                Authorization: `Basic ${Buffer.from(`${config.clientId}:${config.apiToken}`).toString("base64")}`,
+                "Content-Type": "application/json",
+                "X-Snowflake-Database": config.extra?.database || "MAIN",
+                "X-Snowflake-Schema": config.extra?.schema || "PUBLIC",
+                "X-Snowflake-Role": config.extra?.role || "ACCOUNTADMIN",
+            },
+            body: JSON.stringify({ statement: sql, timeout: 30 }),
+        });
+        if (!resp.ok)
+            throw new Error(`Snowflake ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.querySnowflake(config, "SELECT CURRENT_VERSION()");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const policies = await this.querySnowflake(config, "SELECT * FROM information_schema.policy_references WHERE POLICY_KIND = 'ROW_ACCESS_POLICY'").catch(() => ({ result: { rowset: [] } }));
+        const policyRowset = (policies.result?.rowset || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "sf-access-policies",
+            timestamp: now,
+            hash: hashEvidence({ policyCount: policyRowset.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "snowflake/policy_references",
+            status: "unknown",
+            data: { policies: policyRowset },
+            metadata: { account: config.extra?.account || "" },
+        });
+        const queries = await this.querySnowflake(config, "SELECT query_text, user_name, start_time FROM table(information_schema.query_history(limit => 100)) ORDER BY start_time DESC").catch(() => ({ result: { rowset: [] } }));
+        const queryRowset = (queries.result?.rowset || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "sf-query-history",
+            timestamp: now,
+            hash: hashEvidence({ queryCount: queryRowset.length }),
+            framework: "SOC2",
+            controlId: "CC7.1",
+            source: "snowflake/query_history",
+            status: "unknown",
+            data: { queryCount: queryRowset.length },
+            metadata: { account: config.extra?.account || "" },
+        });
+        const copyHistory = await this.querySnowflake(config, "SELECT * FROM table(information_schema.copy_history(table_name => '%%', start_time => dateadd(day, -7, current_timestamp())))").catch(() => ({ result: { rowset: [] } }));
+        const copyRowset = (copyHistory.result?.rowset || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "sf-data-access",
+            timestamp: now,
+            hash: hashEvidence({ copyOperations: copyRowset.length }),
+            framework: "ISO27001",
+            controlId: "A.12.4.1",
+            source: "snowflake/copy_history",
+            status: "unknown",
+            data: { copyOperations: copyRowset.length },
+            metadata: { account: config.extra?.account || "" },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/SnykConnector.d.ts

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

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

@@ -0,0 +1,106 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "tfc-workspaces",
+        name: "Workspace Configs",
+        description: "Fetch Terraform Cloud workspace configurations and variables",
+        evidenceCategories: ["iac", "configuration"],
+    },
+    {
+        id: "tfc-state",
+        name: "State Files",
+        description: "Fetch state file metadata and resource counts",
+        evidenceCategories: ["iac", "change_management"],
+    },
+    {
+        id: "tfc-drift",
+        name: "Drift Detection",
+        description: "Fetch drift detection results and policy violations",
+        evidenceCategories: ["iac", "compliance"],
+    },
+];
+export class TerraformCloudConnector {
+    id = "terraform-cloud";
+    name = "Terraform Cloud";
+    category = "iac";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001", "NIST_CSF"];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://app.terraform.io/api/v2";
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/vnd.api+json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Terraform Cloud API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/organizations?filter[name]=default");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const org = config.extra?.org || "default";
+        const workspaces = await this.fetchApi(config, `/organizations/${org}/workspaces`).catch(() => ({ data: [] }));
+        const wsList = Array.isArray(workspaces.data) ? workspaces.data : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "tfc-workspaces",
+            timestamp: now,
+            hash: hashEvidence({ workspaceCount: wsList.length }),
+            framework: "SOC2",
+            controlId: "CC8.1",
+            source: `terraform-cloud/organizations/${org}/workspaces`,
+            status: "unknown",
+            data: { workspaceCount: wsList.length },
+            metadata: { org },
+        });
+        const wsId = config.extra?.workspaceId || wsList[0]?.id || "";
+        const state = wsId
+            ? await this.fetchApi(config, `/workspaces/${wsId}/current-state-version`)
+                .catch(() => ({ data: null }))
+            : { data: null };
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "tfc-state",
+            timestamp: now,
+            hash: hashEvidence(state),
+            framework: "ISO27001",
+            controlId: "A.12.3.1",
+            source: `terraform-cloud/workspaces/${wsId}/state`,
+            status: state.data ? "compliant" : "non_compliant",
+            data: { stateVersion: state.data },
+            metadata: { org, workspaceId: wsId },
+        });
+        const runs = wsId
+            ? await this.fetchApi(config, `/workspaces/${wsId}/runs?filter[status]=planned,errored&filter[kinds][]=drift`).catch(() => ({ data: [] }))
+            : { data: [] };
+        const runList = Array.isArray(runs.data) ? runs.data : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "tfc-drift",
+            timestamp: now,
+            hash: hashEvidence({ driftRuns: runList.length }),
+            framework: "SOC2",
+            controlId: "CC8.1",
+            source: `terraform-cloud/workspaces/${wsId}/drift`,
+            status: runList.length === 0 ? "compliant" : "non_compliant",
+            data: { driftRuns: runList.length },
+            metadata: { org, workspaceId: wsId },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/index.d.ts

@@ -0,0 +1,25 @@
+export { GitHubConnector } from "./GitHubConnector.js";
+export { GitLabConnector } from "./GitLabConnector.js";
+export { AWSIAMConnector } from "./AWSIAMConnector.js";
+export { AWSS3Connector } from "./AWSS3Connector.js";
+export { AWSCloudTrailConnector } from "./AWSCloudTrailConnector.js";
+export { AzureADConnector } from "./AzureADConnector.js";
+export { AzureSentinelConnector } from "./AzureSentinelConnector.js";
+export { GCPIAMConnector } from "./GCPIAMConnector.js";
+export { GCPSCCConnector } from "./GCPSCCConnector.js";
+export { OktaConnector } from "./OktaConnector.js";
+export { JiraConnector } from "./JiraConnector.js";
+export { SlackConnector } from "./SlackConnector.js";
+export { PagerDutyConnector } from "./PagerDutyConnector.js";
+export { SnowflakeConnector } from "./SnowflakeConnector.js";
+export { DatadogConnector } from "./DatadogConnector.js";
+export { CrowdStrikeConnector } from "./CrowdStrikeConnector.js";
+export { QualysConnector } from "./QualysConnector.js";
+export { SnykConnector } from "./SnykConnector.js";
+export { TerraformCloudConnector } from "./TerraformCloudConnector.js";
+export { GitHubActionsConnector } from "./GitHubActionsConnector.js";
+export { DockerHubConnector } from "./DockerHubConnector.js";
+export { KubernetesConnector } from "./KubernetesConnector.js";
+export { SalesforceConnector } from "./SalesforceConnector.js";
+export { HubSpotConnector } from "./HubSpotConnector.js";
+export { BambooHRConnector } from "./BambooHRConnector.js";

package/dist/connectors/index.js

@@ -0,0 +1,25 @@
+export { GitHubConnector } from "./GitHubConnector.js";
+export { GitLabConnector } from "./GitLabConnector.js";
+export { AWSIAMConnector } from "./AWSIAMConnector.js";
+export { AWSS3Connector } from "./AWSS3Connector.js";
+export { AWSCloudTrailConnector } from "./AWSCloudTrailConnector.js";
+export { AzureADConnector } from "./AzureADConnector.js";
+export { AzureSentinelConnector } from "./AzureSentinelConnector.js";
+export { GCPIAMConnector } from "./GCPIAMConnector.js";
+export { GCPSCCConnector } from "./GCPSCCConnector.js";
+export { OktaConnector } from "./OktaConnector.js";
+export { JiraConnector } from "./JiraConnector.js";
+export { SlackConnector } from "./SlackConnector.js";
+export { PagerDutyConnector } from "./PagerDutyConnector.js";
+export { SnowflakeConnector } from "./SnowflakeConnector.js";
+export { DatadogConnector } from "./DatadogConnector.js";
+export { CrowdStrikeConnector } from "./CrowdStrikeConnector.js";
+export { QualysConnector } from "./QualysConnector.js";
+export { SnykConnector } from "./SnykConnector.js";
+export { TerraformCloudConnector } from "./TerraformCloudConnector.js";
+export { GitHubActionsConnector } from "./GitHubActionsConnector.js";
+export { DockerHubConnector } from "./DockerHubConnector.js";
+export { KubernetesConnector } from "./KubernetesConnector.js";
+export { SalesforceConnector } from "./SalesforceConnector.js";
+export { HubSpotConnector } from "./HubSpotConnector.js";
+export { BambooHRConnector } from "./BambooHRConnector.js";

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { IntegrationMarketplace } from "./IntegrationMarketplace.js";
+export type { CollectionJob } from "./IntegrationMarketplace.js";
+export { GitHubConnector, GitLabConnector, AWSIAMConnector, AWSS3Connector, AWSCloudTrailConnector, AzureADConnector, AzureSentinelConnector, GCPIAMConnector, GCPSCCConnector, OktaConnector, JiraConnector, SlackConnector, PagerDutyConnector, SnowflakeConnector, DatadogConnector, CrowdStrikeConnector, QualysConnector, SnykConnector, TerraformCloudConnector, GitHubActionsConnector, DockerHubConnector, KubernetesConnector, SalesforceConnector, HubSpotConnector, BambooHRConnector, } from "./connectors/index.js";
+export type { IntegrationConnector, ConnectorConfig, ConnectorRegistration, EvidenceArtifact, IntegrationCapability, IntegrationCategory, AuthType, ComplianceFramework, EvidenceStatus, MarketplaceStats, } from "./types.js";
+export { hashEvidence, generateEvidenceId } from "./types.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { IntegrationMarketplace } from "./IntegrationMarketplace.js";
+export { GitHubConnector, GitLabConnector, AWSIAMConnector, AWSS3Connector, AWSCloudTrailConnector, AzureADConnector, AzureSentinelConnector, GCPIAMConnector, GCPSCCConnector, OktaConnector, JiraConnector, SlackConnector, PagerDutyConnector, SnowflakeConnector, DatadogConnector, CrowdStrikeConnector, QualysConnector, SnykConnector, TerraformCloudConnector, GitHubActionsConnector, DockerHubConnector, KubernetesConnector, SalesforceConnector, HubSpotConnector, BambooHRConnector, } from "./connectors/index.js";
+export { hashEvidence, generateEvidenceId } from "./types.js";

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};