AGENT SKILL

twinmind-enterprise-rbac

Implement enterprise role-based access control for TwinMind. Use when setting up team permissions, configuring SSO/SAML, or implementing organization-level access policies. Trigger with phrases like "twinmind RBAC", "twinmind permissions", "twinmind enterprise access", "twinmind SSO", "twinmind team management".

License 许可
MIT
最近更新
2026-11-15
Stars
★ 2.0k
Forks
233

01 前言 Front Matter

name
twinmind-enterprise-rbac
author
Jeremy Longshore <jeremy@intentsolutions.io>
license
MIT
version
1.0.0
description
Implement enterprise role-based access control for TwinMind. Use when setting up team permissions, configuring SSO/SAML, or implementing organization-level access policies. Trigger with phrases like "twinmind RBAC", "twinmind permissions", "twinmind enterprise access", "twinmind SSO", "twinmind team management".
allowed-tools
Read, Write, Edit

03 SKILL.md 正文

TwinMind Enterprise RBAC

Overview

Enterprise-grade role-based access control for TwinMind with SSO integration, team management, and audit capabilities.

Prerequisites

  • TwinMind Enterprise account
  • Admin access to TwinMind organization
  • Identity provider (Okta, Azure AD, Google Workspace)
  • Understanding of RBAC concepts

Instructions

Step 1: Define Roles and Permissions

// src/twinmind/rbac/roles.ts
export enum Permission {
  // Transcript permissions
  TRANSCRIPT_CREATE = 'transcript:create',
  TRANSCRIPT_READ = 'transcript:read',
  TRANSCRIPT_READ_ALL = 'transcript:read:all',  // Read any transcript
  TRANSCRIPT_DELETE = 'transcript:delete',
  TRANSCRIPT_DELETE_ALL = 'transcript:delete:all',

  // Summary permissions
  SUMMARY_GENERATE = 'summary:generate',
  SUMMARY_READ = 'summary:read',

  // Action item permissions
  ACTION_ITEM_CREATE = 'action_item:create',
  ACTION_ITEM_ASSIGN = 'action_item:assign',
  ACTION_ITEM_DELETE = 'action_item:delete',

  // Team permissions
  TEAM_VIEW = 'team:view',
  TEAM_MANAGE = 'team:manage',
  TEAM_INVITE = 'team:invite',
  TEAM_REMOVE = 'team:remove',

  // Settings permissions
  SETTINGS_VIEW = 'settings:view',
  SETTINGS_MANAGE = 'settings:manage',
  INTEGRATIONS_MANAGE = 'integrations:manage',

  // Billing permissions
  BILLING_VIEW = 'billing:view',
  BILLING_MANAGE = 'billing:manage',

  // Admin permissions
  ADMIN_FULL = 'admin:*',
  AUDIT_VIEW = 'audit:view',
  COMPLIANCE_MANAGE = 'compliance:manage',
}

export interface Role {
  name: string;
  description: string;
  permissions: Permission[];
  inherits?: string[];  // Inherit from other roles
}

export const predefinedRoles: Record<string, Role> = {
  viewer: {
    name: 'Viewer',
    description: 'Can view own transcripts and summaries',
    permissions: [
      Permission.TRANSCRIPT_READ,
      Permission.SUMMARY_READ,
    ],
  },

  member: {
    name: 'Member',
    description: 'Standard team member with create access',
    permissions: [
      Permission.TRANSCRIPT_CREATE,
      Permission.TRANSCRIPT_READ,
      Permission.TRANSCRIPT_DELETE,
      Permission.SUMMARY_GENERATE,
      Permission.SUMMARY_READ,
      Permission.ACTION_ITEM_CREATE,
    ],
    inherits: ['viewer'],
  },

  manager: {
    name: 'Manager',
    description: 'Can manage team transcripts and members',
    permissions: [
      Permission.TRANSCRIPT_READ_ALL,
      Permission.TRANSCRIPT_DELETE_ALL,
      Permission.ACTION_ITEM_ASSIGN,
      Permission.ACTION_ITEM_DELETE,
      Permission.TEAM_VIEW,
      Permission.TEAM_INVITE,
    ],
    inherits: ['member'],
  },

  admin: {
    name: 'Admin',
    description: 'Full organizational admin access',
    permissions: [
      Permission.TEAM_MANAGE,
      Permission.TEAM_REMOVE,
      Permission.SETTINGS_VIEW,
      Permission.SETTINGS_MANAGE,
      Permission.INTEGRATIONS_MANAGE,
      Permission.BILLING_VIEW,
      Permission.AUDIT_VIEW,
    ],
    inherits: ['manager'],
  },

  owner: {
    name: 'Owner',
    description: 'Organization owner with full access',
    permissions: [
      Permission.ADMIN_FULL,
      Permission.BILLING_MANAGE,
      Permission.COMPLIANCE_MANAGE,
    ],
    inherits: ['admin'],
  },
};

// Resolve all permissions for a role (including inherited)
export function resolvePermissions(roleName: string): Permission[] {
  const role = predefinedRoles[roleName];
  if (!role) return [];

  const permissions = new Set<Permission>(role.permissions);

  for (const inheritedRole of role.inherits || []) {
    const inheritedPermissions = resolvePermissions(inheritedRole);
    inheritedPermissions.forEach(p => permissions.add(p));
  }

  return Array.from(permissions);
}

Step 2: Implement Permission Checking

// src/twinmind/rbac/authorization.ts
import { Permission, resolvePermissions } from './roles';

export interface User {
  id: string;
  email: string;
  organizationId: string;
  role: string;
  customPermissions?: Permission[];  // Additional granted permissions
  deniedPermissions?: Permission[];  // Explicitly denied
}

export class AuthorizationService {
  hasPermission(user: User, permission: Permission): boolean {
    // Check for admin wildcard
    const userPermissions = this.getUserPermissions(user);

    if (userPermissions.includes(Permission.ADMIN_FULL)) {
      return true;
    }

    // Check denied list first
    if (user.deniedPermissions?.includes(permission)) {
      return false;
    }

    // Check for exact permission or wildcard
    return userPermissions.includes(permission) ||
           this.matchesWildcard(permission, userPermissions);
  }

  hasAnyPermission(user: User, permissions: Permission[]): boolean {
    return permissions.some(p => this.hasPermission(user, p));
  }

  hasAllPermissions(user: User, permissions: Permission[]): boolean {
    return permissions.every(p => this.hasPermission(user, p));
  }

  private getUserPermissions(user: User): Permission[] {
    const rolePermissions = resolvePermissions(user.role);
    const customPermissions = user.customPermissions || [];

    return [...new Set([...rolePermissions, ...customPermissions])];
  }

  private matchesWildcard(permission: Permission, userPermissions: Permission[]): boolean {
    const [resource] = permission.split(':');
    const wildcardPermission = `${resource}:*` as Permission;
    return userPermissions.includes(wildcardPermission);
  }
}

// Express middleware
export function requirePermission(...permissions: Permission[]) {
  const authService = new AuthorizationService();

  return (req: Request, res: Response, next: NextFunction) => {
    const user = req.user as User;

    if (!user) {
      return res.status(401).json({ error: 'Unauthorized' });
    }

    if (!authService.hasAnyPermission(user, permissions)) {
      return res.status(403).json({
        error: 'Insufficient permissions',
        required: permissions,
        user_role: user.role,
      });
    }

    next();
  };
}

// Resource-level authorization
export function canAccessTranscript(user: User, transcript: Transcript): boolean {
  const authService = new AuthorizationService();

  // Admins can access all
  if (authService.hasPermission(user, Permission.TRANSCRIPT_READ_ALL)) {
    return true;
  }

  // Check if user owns the transcript
  if (transcript.created_by === user.id) {
    return authService.hasPermission(user, Permission.TRANSCRIPT_READ);
  }

  // Check if user was a participant
  if (transcript.participants?.some(p => p.email === user.email)) {
    return authService.hasPermission(user, Permission.TRANSCRIPT_READ);
  }

  return false;
}

Step 3: Configure SSO/SAML Integration

// src/twinmind/rbac/sso.ts
import { Strategy as SamlStrategy } from 'passport-saml';
import passport from 'passport';

export interface SSOConfig {
  provider: 'okta' | 'azure' | 'google' | 'onelogin';
  entryPoint: string;          // IdP SSO URL
  issuer: string;              // SP Entity ID
  cert: string;                // IdP Certificate
  callbackUrl: string;         // ACS URL
  signatureAlgorithm?: string;
  identifierFormat?: string;
  attributeMapping: {
    email: string;
    firstName: string;
    lastName: string;
    groups?: string;
  };
  groupRoleMapping?: Record<string, string>;  // IdP group -> TwinMind role
}

export function configureSAML(config: SSOConfig): void {
  const samlStrategy = new SamlStrategy(
    {
      entryPoint: config.entryPoint,
      issuer: config.issuer,
      cert: config.cert,
      callbackUrl: config.callbackUrl,
      signatureAlgorithm: config.signatureAlgorithm || 'sha256',
      identifierFormat: config.identifierFormat || 'urn:oasis:names:tc:SAML:1.1:nameid-format:emailAddress',
    },
    async (profile, done) => {
      try {
        // Extract user attributes
        const email = profile[config.attributeMapping.email];
        const firstName = profile[config.attributeMapping.firstName];
        const lastName = profile[config.attributeMapping.lastName];
        const groups = profile[config.attributeMapping.groups || 'groups'] || [];

        // Map IdP groups to TwinMind roles
        let role = 'member';  // Default role
        if (config.groupRoleMapping) {
          for (const [group, mappedRole] of Object.entries(config.groupRoleMapping)) {
            if (groups.includes(group)) {
              role = mappedRole;
              break;
            }
          }
        }

        // Find or create user
        const user = await findOrCreateUser({
          email,
          firstName,
          lastName,
          role,
          authProvider: 'saml',
          authProviderId: profile.nameID,
        });

        done(null, user);
      } catch (error) {
        done(error as Error);
      }
    }
  );

  passport.use('saml', samlStrategy);
}

// Example Okta configuration
export const oktaConfig: SSOConfig = {
  provider: 'okta',
  entryPoint: process.env.OKTA_SSO_URL!,
  issuer: process.env.OKTA_ISSUER!,
  cert: process.env.OKTA_CERT!,
  callbackUrl: `${process.env.APP_URL}/auth/saml/callback`,
  attributeMapping: {
    email: 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress',
    firstName: 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname',
    lastName: 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/surname',
    groups: 'http://schemas.xmlsoap.org/claims/Group',
  },
  groupRoleMapping: {
    'TwinMind-Admins': 'admin',
    'TwinMind-Managers': 'manager',
    'TwinMind-Members': 'member',
    'TwinMind-Viewers': 'viewer',
  },
};

Step 4: Team Management

// src/twinmind/rbac/teams.ts
export interface Team {
  id: string;
  name: string;
  organizationId: string;
  members: TeamMember[];
  settings: TeamSettings;
}

export interface TeamMember {
  userId: string;
  email: string;
  role: string;
  joinedAt: Date;
  invitedBy: string;
}

export interface TeamSettings {
  defaultTranscriptVisibility: 'private' | 'team' | 'organization';
  allowExternalSharing: boolean;
  requireApprovalForSharing: boolean;
  autoTranscribe: boolean;
}

export class TeamManager {
  private client = getTwinMindClient();
  private authService = new AuthorizationService();

  async createTeam(name: string, creatorId: string): Promise<Team> {
    const response = await this.client.post('/teams', {
      name,
      settings: {
        defaultTranscriptVisibility: 'team',
        allowExternalSharing: false,
        requireApprovalForSharing: true,
        autoTranscribe: true,
      },
    });

    // Add creator as owner
    await this.addMember(response.data.id, creatorId, 'owner');

    return response.data;
  }

  async addMember(
    teamId: string,
    userId: string,
    role: string,
    invitedBy?: string
  ): Promise<void> {
    await this.client.post(`/teams/${teamId}/members`, {
      user_id: userId,
      role,
      invited_by: invitedBy,
    });

    // Sync to TwinMind organization
    await this.syncToTwinMind(teamId);
  }

  async removeMember(teamId: string, userId: string): Promise<void> {
    await this.client.delete(`/teams/${teamId}/members/${userId}`);
    await this.syncToTwinMind(teamId);
  }

  async updateMemberRole(teamId: string, userId: string, newRole: string): Promise<void> {
    await this.client.patch(`/teams/${teamId}/members/${userId}`, {
      role: newRole,
    });
  }

  async getTeamMembers(teamId: string): Promise<TeamMember[]> {
    const response = await this.client.get(`/teams/${teamId}/members`);
    return response.data;
  }

  async inviteMember(
    teamId: string,
    email: string,
    role: string,
    invitedBy: User
  ): Promise<void> {
    // Check permission
    if (!this.authService.hasPermission(invitedBy, Permission.TEAM_INVITE)) {
      throw new Error('Insufficient permissions to invite team members');
    }

    // Send invitation
    await this.client.post(`/teams/${teamId}/invitations`, {
      email,
      role,
      invited_by: invitedBy.id,
    });

    // Send invitation email
    await sendInvitationEmail(email, teamId, invitedBy);
  }

  private async syncToTwinMind(teamId: string): Promise<void> {
    const members = await this.getTeamMembers(teamId);

    await this.client.put(`/organization/members`, {
      members: members.map(m => ({
        email: m.email,
        role: m.role,
      })),
    });
  }
}

Step 5: Audit Logging for Access

// src/twinmind/rbac/audit.ts
export interface AccessAuditEvent {
  timestamp: Date;
  userId: string;
  userEmail: string;
  action: string;
  resource: string;
  resourceId?: string;
  granted: boolean;
  reason?: string;
  ipAddress?: string;
  userAgent?: string;
  metadata?: Record<string, any>;
}

export class AccessAuditLogger {
  async logAccess(event: Omit<AccessAuditEvent, 'timestamp'>): Promise<void> {
    const fullEvent: AccessAuditEvent = {
      ...event,
      timestamp: new Date(),
    };

    // Store in database
    await db.accessAuditLogs.create(fullEvent);

    // Send to SIEM if configured
    if (process.env.SIEM_ENDPOINT) {
      await this.sendToSIEM(fullEvent);
    }

    // Log denied access at warning level
    if (!event.granted) {
      logger.warn('Access denied', {
        user: event.userEmail,
        action: event.action,
        resource: event.resource,
        reason: event.reason,
      });
    }
  }

  async queryAuditLogs(filters: {
    userId?: string;
    action?: string;
    resource?: string;
    granted?: boolean;
    from?: Date;
    to?: Date;
    limit?: number;
  }): Promise<AccessAuditEvent[]> {
    return db.accessAuditLogs.find({
      ...filters,
      timestamp: {
        $gte: filters.from,
        $lte: filters.to,
      },
    }).limit(filters.limit || 100);
  }

  async generateAccessReport(
    userId: string,
    dateRange: { from: Date; to: Date }
  ): Promise<{
    totalAccesses: number;
    deniedAccesses: number;
    resourcesAccessed: string[];
    uniqueResources: number;
  }> {
    const logs = await this.queryAuditLogs({
      userId,
      from: dateRange.from,
      to: dateRange.to,
    });

    const resourcesAccessed = logs
      .filter(l => l.granted)
      .map(l => l.resource);

    return {
      totalAccesses: logs.filter(l => l.granted).length,
      deniedAccesses: logs.filter(l => !l.granted).length,
      resourcesAccessed,
      uniqueResources: new Set(resourcesAccessed).size,
    };
  }

  private async sendToSIEM(event: AccessAuditEvent): Promise<void> {
    await fetch(process.env.SIEM_ENDPOINT!, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        source: 'twinmind-integration',
        event_type: 'access_audit',
        ...event,
      }),
    });
  }
}

// Middleware to audit all accesses
export function auditMiddleware(auditLogger: AccessAuditLogger) {
  return async (req: Request, res: Response, next: NextFunction) => {
    const originalSend = res.send;
    const user = req.user as User;

    res.send = function(body) {
      const granted = res.statusCode < 400;

      auditLogger.logAccess({
        userId: user?.id || 'anonymous',
        userEmail: user?.email || 'anonymous',
        action: `${req.method} ${req.path}`,
        resource: req.path.split('/')[2] || 'unknown',
        resourceId: req.params.id,
        granted,
        reason: !granted ? body?.error : undefined,
        ipAddress: req.ip,
        userAgent: req.headers['user-agent'],
      });

      return originalSend.call(this, body);
    };

    next();
  };
}

Output

  • Role and permission definitions
  • Permission checking service
  • SSO/SAML configuration
  • Team management functionality
  • Access audit logging

Role Hierarchy

Owner
  └── Admin
        └── Manager
              └── Member
                    └── Viewer

Enterprise Features

Feature Description Configuration
SSO/SAML Single sign-on integration IdP configuration
SCIM User provisioning Automatic sync
Custom roles Define organization roles Role builder
Audit logs Access tracking 90-day retention
IP allowlisting Restrict access by IP Network settings

Error Handling

Issue Cause Solution
SSO login failed Certificate mismatch Update IdP cert
Role not syncing SCIM misconfigured Check provisioning
Permission denied Wrong role assigned Review role mapping
Audit gaps Middleware not applied Add to all routes

Resources

Next Steps

For migration from other tools, see twinmind-migration-deep-dive.

04 同仓库更多 Skills

Dicklesworthstone
Dicklesworthstone/pi_agent_rust

theme-factory

Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors/fonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.

视觉设计
★ 2.0k
Dicklesworthstone
Dicklesworthstone/pi_agent_rust

web-artifacts-builder

Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use for complex artifacts requiring state management, routing, or shadcn/ui components - not for simple single-file HTML/JSX artifacts.

前端开发
★ 2.0k
Dicklesworthstone
Dicklesworthstone/pi_agent_rust

webapp-testing

Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.

测试与质量前端开发
★ 2.0k
Dicklesworthstone
Dicklesworthstone/pi_agent_rust

neuropixels-analysis

Neuropixels neural recording analysis. Load SpikeGLX/OpenEphys data, preprocess, motion correction, Kilosort4 spike sorting, quality metrics, Allen/IBL curation, AI-assisted visual analysis, for Neuropixels 1.0/2.0 extracellular electrophysiology. Use when working with neural recordings, spike sorting, extracellular electrophysiology, or when the user mentions Neuropixels, SpikeGLX, Open Ephys, Kilosort, quality metrics, or unit curation.

★ 2.0k
Dicklesworthstone
Dicklesworthstone/pi_agent_rust

skill-creator

Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.

Skill与智能体开发
★ 2.0k
Dicklesworthstone
Dicklesworthstone/pi_agent_rust

notebooklm

Use this skill to query your Google NotebookLM notebooks directly from Claude Code for source-grounded, citation-backed answers from Gemini. Browser automation, library management, persistent auth. Drastically reduced hallucinations through document-only responses.

Skill与智能体开发
★ 2.0k