@grc-claw/integration-marketplace 0.8.0

package/dist/connectors/NetskopeConnector.js

@@ -0,0 +1,98 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "netskope-casb",
+        name: "Cloud Access Security",
+        description: "Fetch CASB policies and shadow IT discoveries",
+        evidenceCategories: ["access_control", "data_protection"],
+    },
+    {
+        id: "netskope-sase",
+        name: "SASE Security",
+        description: "Fetch SASE policies and zero trust network access rules",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "netskope-dlp",
+        name: "Cloud DLP",
+        description: "Fetch DLP policies and incident details",
+        evidenceCategories: ["data_protection", "monitoring"],
+    },
+    {
+        id: "netskope-swg",
+        name: "Secure Web Gateway",
+        description: "Fetch SWG URL filtering and threat protection",
+        evidenceCategories: ["vulnerability_management", "access_control"],
+    },
+];
+export class NetskopeConnector {
+    id = "netskope";
+    name = "Netskope";
+    category = "cloud_provider";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "HIPAA",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://tenant.netskope.com";
+        const resp = await fetch(`${base}/api/v1${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Netskope API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/security/policies");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const policies = await this.fetchApi(config, "/security/policies").catch(() => ({
+            policies: [],
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "netskope-casb",
+            timestamp: now,
+            hash: hashEvidence(policies),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "netskope/security-policies",
+            status: policies.policies?.length > 0 ? "compliant" : "unknown",
+            data: { securityPolicies: policies.policies?.length || 0 },
+            metadata: {},
+        });
+        const incidents = await this.fetchApi(config, "/security/incidents?limit=10").catch(() => ({
+            incidents: [],
+        }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "netskope-dlp",
+            timestamp: now,
+            hash: hashEvidence(incidents),
+            framework: "ISO27001",
+            controlId: "A.8.3.1",
+            source: "netskope/incidents",
+            status: incidents.incidents?.length === 0 ? "compliant" : "non_compliant",
+            data: { openIncidents: incidents.incidents?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/NexusConnector.d.ts

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

@@ -0,0 +1,93 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "nexus-repos",
+        name: "Repository Management",
+        description: "Fetch repository configurations and proxy settings",
+        evidenceCategories: ["access_control", "configuration"],
+    },
+    {
+        id: "nexus-components",
+        name: "Component Security",
+        description: "Fetch component vulnerability and license data",
+        evidenceCategories: ["vulnerability_management", "data_protection"],
+    },
+    {
+        id: "nexus-roles",
+        name: "Role-Based Access",
+        description: "Fetch roles, privileges, and user assignments",
+        evidenceCategories: ["access_control"],
+    },
+    {
+        id: "nexus-audit",
+        name: "Task & Audit Logs",
+        description: "Fetch scheduled tasks and access audit logs",
+        evidenceCategories: ["monitoring", "access_control"],
+    },
+];
+export class NexusConnector {
+    id = "nexus";
+    name = "Sonatype Nexus";
+    category = "ci_cd";
+    authType = "api_key";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || "https://nexus.example.com";
+        const resp = await fetch(`${base}/service/rest${endpoint}`, {
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Nexus API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/v1/status");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const repos = await this.fetchApi(config, "/v1/repositories").catch(() => []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "nexus-repos",
+            timestamp: now,
+            hash: hashEvidence(Array.isArray(repos) ? { count: repos.length } : repos),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "nexus/repositories",
+            status: Array.isArray(repos) && repos.length > 0 ? "compliant" : "unknown",
+            data: { repositoryCount: Array.isArray(repos) ? repos.length : 0 },
+            metadata: {},
+        });
+        const roles = await this.fetchApi(config, "/v1/roles").catch(() => ({ items: [] }));
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "nexus-roles",
+            timestamp: now,
+            hash: hashEvidence(roles),
+            framework: "ISO27001",
+            controlId: "A.6.2.1",
+            source: "nexus/roles",
+            status: roles.items?.length > 0 ? "compliant" : "non_compliant",
+            data: { roleCount: roles.items?.length || 0 },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/NotionConnector.d.ts

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

@@ -0,0 +1,109 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "notion-databases",
+        name: "Databases",
+        description: "Fetch Notion databases used for policy tracking and compliance documentation",
+        evidenceCategories: ["documentation", "policy_management"],
+    },
+    {
+        id: "notion-pages",
+        name: "Pages",
+        description: "Fetch recently modified pages for documentation evidence",
+        evidenceCategories: ["documentation", "knowledge_management"],
+    },
+    {
+        id: "notion-members",
+        name: "Workspace Members",
+        description: "Fetch workspace member list and role assignments",
+        evidenceCategories: ["access_control", "identity_management"],
+    },
+];
+export class NotionConnector {
+    id = "notion";
+    name = "Notion";
+    category = "workspace";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = ["SOC2", "ISO27001"];
+    async fetchApi(config, endpoint, body) {
+        const base = config.baseUrl || "https://api.notion.com/v1";
+        const resp = await fetch(`${base}${endpoint}`, {
+            method: body ? "POST" : "GET",
+            headers: {
+                Authorization: `Bearer ${config.apiToken}`,
+                "Notion-Version": "2022-06-28",
+                "Content-Type": "application/json",
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!resp.ok)
+            throw new Error(`Notion API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/search", { page_size: 1 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const databases = await this.fetchApi(config, "/search", {
+            filter: { property: "object", value: "database" },
+            page_size: 50,
+        }).catch(() => ({ results: [] }));
+        const dbList = (databases.results || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "notion-databases",
+            timestamp: now,
+            hash: hashEvidence({ databaseCount: dbList.length }),
+            framework: "SOC2",
+            controlId: "CC7.1",
+            source: "notion/databases",
+            status: dbList.length > 0 ? "compliant" : "non_compliant",
+            data: { databaseCount: dbList.length },
+            metadata: {},
+        });
+        const pages = await this.fetchApi(config, "/search", {
+            filter: { property: "object", value: "page" },
+            page_size: 50,
+        }).catch(() => ({ results: [] }));
+        const pageList = (pages.results || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "notion-pages",
+            timestamp: now,
+            hash: hashEvidence({ pageCount: pageList.length }),
+            framework: "ISO27001",
+            controlId: "A.7.2.2",
+            source: "notion/pages",
+            status: "unknown",
+            data: { pageCount: pageList.length },
+            metadata: {},
+        });
+        const users = await this.fetchApi(config, "/users").catch(() => ({ results: [] }));
+        const userList = (users.results || []);
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "notion-members",
+            timestamp: now,
+            hash: hashEvidence({ memberCount: userList.length }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "notion/users",
+            status: "unknown",
+            data: { memberCount: userList.length },
+            metadata: {},
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/OktaConnector.d.ts

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

package/dist/connectors/OktaConnector.js

@@ -0,0 +1,123 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "okta-users",
+        name: "User Accounts",
+        description: "Fetch Okta user accounts and status",
+        evidenceCategories: ["identity_management"],
+    },
+    {
+        id: "okta-mfa-factors",
+        name: "MFA Factors",
+        description: "Fetch enrolled MFA factors across users",
+        evidenceCategories: ["authentication"],
+    },
+    {
+        id: "okta-app-assignments",
+        name: "App Assignments",
+        description: "Fetch application assignments and SSO configurations",
+        evidenceCategories: ["access_control"],
+    },
+    {
+        id: "okta-group-memberships",
+        name: "Group Memberships",
+        description: "Fetch group memberships and role assignments",
+        evidenceCategories: ["access_control", "authorization"],
+    },
+];
+export class OktaConnector {
+    id = "okta";
+    name = "Okta";
+    category = "identity";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "HIPAA",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || `https://${config.extra?.domain || "example"}.okta.com/api/v1`;
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: { Authorization: `SSWS ${config.apiToken}` },
+        });
+        if (!resp.ok)
+            throw new Error(`Okta API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/users/me");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const users = await this.fetchApi(config, "/users?filter=status%20eq%20%22ACTIVE%22&limit=200");
+        const userList = Array.isArray(users) ? users : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "okta-users",
+            timestamp: now,
+            hash: hashEvidence({ users: userList.map((u) => ({ id: u.id, status: u.status })) }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "okta/users",
+            status: "compliant",
+            data: { activeUserCount: userList.length },
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        const factors = await this.fetchApi(config, "/users/me/factors").catch(() => []);
+        const factorList = Array.isArray(factors) ? factors : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "okta-mfa-factors",
+            timestamp: now,
+            hash: hashEvidence({ factors: factorList }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: "okta/factors",
+            status: factorList.length > 0 ? "compliant" : "non_compliant",
+            data: { factorTypes: factorList.map((f) => f.factorType) },
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        const apps = await this.fetchApi(config, "/apps?limit=100").catch(() => []);
+        const appList = Array.isArray(apps) ? apps : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "okta-app-assignments",
+            timestamp: now,
+            hash: hashEvidence({ apps: appList.map((a) => ({ id: a.id, name: a.name })) }),
+            framework: "ISO27001",
+            controlId: "A.9.2.5",
+            source: "okta/apps",
+            status: "unknown",
+            data: { appCount: appList.length },
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        const groups = await this.fetchApi(config, "/groups?limit=100").catch(() => []);
+        const groupList = Array.isArray(groups) ? groups : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "okta-group-memberships",
+            timestamp: now,
+            hash: hashEvidence({ groups: groupList.map((g) => ({ id: g.id, name: (g.profile || {}).name })) }),
+            framework: "SOC2",
+            controlId: "CC6.3",
+            source: "okta/groups",
+            status: groupList.length > 0 ? "compliant" : "non_compliant",
+            data: { groupCount: groupList.length },
+            metadata: { domain: config.extra?.domain || "" },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/OktaSystemLogConnector.d.ts

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

package/dist/connectors/OktaSystemLogConnector.js

@@ -0,0 +1,129 @@
+import { hashEvidence, generateEvidenceId } from "../types.js";
+const capabilities = [
+    {
+        id: "okta-system-log",
+        name: "System Log Events",
+        description: "Fetch Okta system log events for authentication and access patterns",
+        evidenceCategories: ["audit", "access_control"],
+    },
+    {
+        id: "okta-failed-logins",
+        name: "Failed Login Events",
+        description: "Fetch failed authentication attempts and lockout events",
+        evidenceCategories: ["access_control", "threat_detection"],
+    },
+    {
+        id: "okta-user-lifecycle",
+        name: "User Lifecycle Events",
+        description: "Fetch user creation, deactivation, and role change events",
+        evidenceCategories: ["access_control", "change_management"],
+    },
+    {
+        id: "okta-mfa-events",
+        name: "MFA Enrollment Events",
+        description: "Fetch MFA factor enrollment and verification events",
+        evidenceCategories: ["access_control", "identity_verification"],
+    },
+];
+export class OktaSystemLogConnector {
+    id = "okta_system_log";
+    name = "Okta System Log";
+    category = "identity";
+    authType = "bearer_token";
+    capabilities = capabilities;
+    frameworks = [
+        "SOC2",
+        "ISO27001",
+        "NIST_CSF",
+        "HIPAA",
+        "PCI_DSS",
+    ];
+    async fetchApi(config, endpoint) {
+        const base = config.baseUrl || `https://${config.extra?.domain || "example"}.okta.com`;
+        const resp = await fetch(`${base}${endpoint}`, {
+            headers: {
+                Authorization: `SSWS ${config.apiToken}`,
+                Accept: "application/json",
+            },
+        });
+        if (!resp.ok)
+            throw new Error(`Okta API ${resp.status}: ${resp.statusText}`);
+        return (await resp.json());
+    }
+    async testConnection(config) {
+        try {
+            await this.fetchApi(config, "/api/v1/users/me");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async collectEvidence(config) {
+        const artifacts = [];
+        const now = new Date().toISOString();
+        const domain = config.extra?.domain || "example";
+        const since = new Date(Date.now() - 86400000).toISOString();
+        const systemLog = await this.fetchApi(config, `/api/v1/logs?since=${since}&limit=100&filter=event-type%20eq%20"user.session.start"`).catch(() => []);
+        const logEntries = Array.isArray(systemLog) ? systemLog : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "okta-system-log",
+            timestamp: now,
+            hash: hashEvidence({ entries: logEntries.slice(0, 10) }),
+            framework: "SOC2",
+            controlId: "CC6.1",
+            source: `okta/${domain}/system-log`,
+            status: logEntries.length > 0 ? "compliant" : "partial",
+            data: { loginEvents: logEntries.length },
+            metadata: { domain },
+        });
+        const failedLogins = await this.fetchApi(config, `/api/v1/logs?since=${since}&limit=100&filter=event-type%20eq%20"user.session.destroy"&filter=outcome.result%20eq%20"FAILURE"`).catch(() => []);
+        const failedEntries = Array.isArray(failedLogins) ? failedLogins : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "okta-failed-logins",
+            timestamp: now,
+            hash: hashEvidence({ entries: failedEntries.slice(0, 10) }),
+            framework: "ISO27001",
+            controlId: "A.9.4.2",
+            source: `okta/${domain}/failed-logins`,
+            status: failedEntries.length < 10 ? "compliant" : "non_compliant",
+            data: { failedLoginCount: failedEntries.length },
+            metadata: { domain },
+        });
+        const lifecycle = await this.fetchApi(config, `/api/v1/logs?since=${since}&limit=50&filter=event-type%20sw%20"user.lifecycle"`).catch(() => []);
+        const lifecycleEntries = Array.isArray(lifecycle) ? lifecycle : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "okta-user-lifecycle",
+            timestamp: now,
+            hash: hashEvidence({ entries: lifecycleEntries.slice(0, 10) }),
+            framework: "NIST_CSF",
+            controlId: "PR.AC",
+            source: `okta/${domain}/lifecycle`,
+            status: "compliant",
+            data: { lifecycleEvents: lifecycleEntries.length },
+            metadata: { domain },
+        });
+        const mfaEvents = await this.fetchApi(config, `/api/v1/logs?since=${since}&limit=50&filter=event-type%20sw%20"factor.enroll"`).catch(() => []);
+        const mfaEntries = Array.isArray(mfaEvents) ? mfaEvents : [];
+        artifacts.push({
+            id: generateEvidenceId(),
+            connectorId: this.id,
+            capabilityId: "okta-mfa-events",
+            timestamp: now,
+            hash: hashEvidence({ entries: mfaEntries.slice(0, 10) }),
+            framework: "PCI_DSS",
+            controlId: "8.3",
+            source: `okta/${domain}/mfa-enrollment`,
+            status: "compliant",
+            data: { mfaEnrollments: mfaEntries.length },
+            metadata: { domain },
+        });
+        return artifacts;
+    }
+}

package/dist/connectors/OpsgenieConnector.d.ts

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