Claude Code 企业级部署全攻略 — 团队配置共享、安全策略、集中 Rules、合规审查与 SSO 集成

┌──────────────────────────────────────────────────────────────────┐
│                        企业网络边界                              │
│                                                                  │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐          │
│  │  Developer 1 │    │  Developer 2 │    │  Developer N │          │
│  │  Claude Code│    │  Claude Code│    │  Claude Code │          │
│  └──────┬──────┘    └──────┬──────┘    └──────┬──────┘          │
│         │                  │                  │                  │
│  ┌──────┴──────────────────┴──────────────────┴──────┐          │
│  │              配置管理层 (Config Server)             │          │
│  │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │          │
│  │  │ 全局     │ │ 团队    │ │ 项目    │ │ 个人    │ │          │
│  │  │ Rules   │ │ Rules   │ │ Rules   │ │ 覆盖    │ │          │
│  │  └─────────┘ └─────────┘ └─────────┘ └─────────┘ │          │
│  └──────────────────────┬────────────────────────────┘          │
│                         │                                       │
│  ┌──────────────────────┴────────────────────────────┐          │
│  │              安全网关 (Security Proxy)              │          │
│  │  ┌──────────┐ ┌──────────┐ ┌──────────┐          │          │
│  │  │ DLP 检查  │ │ 审计日志  │ │ 策略引擎  │          │          │
│  │  └──────────┘ └──────────┘ └──────────┘          │          │
│  └──────────────────────┬────────────────────────────┘          │
│                         │                                       │
│  ┌──────────────────────┴────────────────────────────┐          │
│  │              身份认证 (SSO/IAM)                     │          │
│  │  Okta / Azure AD / Keycloak / LDAP                │          │
│  └───────────────────────────────────────────────────┘          │
│                                                                  │
└─────────────────────────┬────────────────────────────────────────┘
                          │
                    外部 API 调用
                    (Anthropic API)

优先级（低 → 高）：

1. 系统默认配置        → 内置的安全限制和默认行为
2. 组织全局配置         → /etc/claude-code/config.yaml
3. 团队配置            → $ORG_CONFIG/teams/<team>/config.yaml
4. 项目配置 (.claude/)  → 仓库根目录的 .claude/ 目录
5. 用户个人配置         → ~/.claude-code/settings.json
6. 命令行参数          → 运行时显式指定的参数

team-config/                          # 专用配置仓库
├── global/
│   ├── config.yaml                   # 全局策略
│   └── CLAUDE.md                     # 全局行为规则
├── teams/
│   ├── backend/
│   │   ├── config.yaml               # 后端团队策略
│   │   └── CLAUDE.md                 # 后端编码规范
│   ├── frontend/
│   │   ├── config.yaml
│   │   └── CLAUDE.md
│   └── devops/
│       ├── config.yaml
│       └── CLAUDE.md
├── projects/
│   ├── payment-service/
│   │   └── CLAUDE.md                 # 项目级规则（安全要求更高）
│   └── user-portal/
│       └── CLAUDE.md
└── scripts/
    └── sync-config.sh                # 配置同步脚本

#!/bin/bash
# sync-claude-config.sh - 同步团队配置到本地

CONFIG_REPO="git@github.com:myorg/claude-team-config.git"
CONFIG_DIR="${CLAUDE_CODE_CONFIG_HOME:-$HOME/.claude-code}"
TEAM="${1:-backend}"  # 默认同步后端团队配置

echo "🔄 同步 Claude Code 团队配置..."

# 拉取最新配置
tmp_dir=$(mktemp -d)
git clone --depth 1 "$CONFIG_REPO" "$tmp_dir"

# 备份当前配置
if [ -d "$CONFIG_DIR" ]; then
    backup_dir="$CONFIG_DIR/backup-$(date +%Y%m%d)"
    mkdir -p "$backup_dir"
    cp -r "$CONFIG_DIR"/{settings.json,CLAUDE.md,config.yaml} "$backup_dir" 2>/dev/null
    echo "  📦 已备份到 $backup_dir"
fi

# 应用全局配置
mkdir -p "$CONFIG_DIR"
cp "$tmp_dir/global/config.yaml" "$CONFIG_DIR/"
cp "$tmp_dir/global/CLAUDE.md" "$CONFIG_DIR/"

# 应用团队配置
if [ -d "$tmp_dir/teams/$TEAM" ]; then
    mkdir -p "$CONFIG_DIR/team"
    cp "$tmp_dir/teams/$TEAM/CLAUDE.md" "$CONFIG_DIR/team/"
    echo "  ✅ 团队配置: $TEAM"
else
    echo "  ⚠️ 未找到团队配置: $TEAM"
fi

# 清理
rm -rf "$tmp_dir"
echo "✅ 配置同步完成"

#!/bin/bash
# .git/hooks/post-checkout — 切换分支/仓库时自动更新 Claude 配置

REPO_ROOT=$(git rev-parse --show-toplevel)
CLAUDE_DIR="$REPO_ROOT/.claude"

if [ -f "$CLAUDE_DIR/config.yaml" ]; then
    echo "📋 检测到项目级 Claude 配置，正在应用..."
    # 可以在此触发配置合并逻辑
fi

<!-- Jamf Pro 配置描述符 -->
<dict>
    <key>PayloadType</key>
    <string>com.anthropic.claude-code</string>
    <key>PayloadDisplayName</key>
    <string>Claude Code 企业配置</string>
    <key>CLAUDE_CODE_CONFIG_PATH</key>
    <string>/Library/Management/ClaudeCode/config.yaml</string>
    <key>CLAUDE_CODE_MAX_BUDGET_USD</key>
    <string>10</string>
    <key>CLAUDE_CODE_ALLOWED_MODELS</key>
    <array>
        <string>sonnet</string>
        <string>haiku</string>
    </array>
    <key>CLAUDE_CODE_SSO_PROVIDER</key>
    <string>okta</string>
</dict>

┌─────────────────────────────────────────────┐
│  Layer 4: 网络层安全                         │
│  - VPC 隔离                                 │
│  - API Gateway 策略                          │
│  - TLS 加密传输                              │
├─────────────────────────────────────────────┤
│  Layer 3: 应用层安全                         │
│  - 权限沙箱 (文件系统/网络/命令)              │
│  - allow/deny 规则                           │
│  - 敏感文件保护                              │
├─────────────────────────────────────────────┤
│  Layer 2: 数据层安全                         │
│  - DLP (数据泄露防护)                        │
│  - PII 自动检测与脱敏                        │
│  - 代码片段审计                              │
├─────────────────────────────────────────────┤
│  Layer 1: 身份层安全                         │
│  - SSO 认证                                  │
│  - MFA 多因素认证                            │
│  - 基于角色的访问控制 (RBAC)                  │
└─────────────────────────────────────────────┘

# .claude/security-policy.yaml
filesystem:
  # 允许读写的目录
  allow_rw:
    - "src/**"
    - "tests/**"
    - "docs/**"

  # 只读目录
  allow_read:
    - "node_modules/**"
    - "vendor/**"
    - ".github/**"

  # 绝对禁止访问（即使 Claude 请求也不行）
  deny:
    - ".env"
    - ".env.*"
    - "**/*.pem"
    - "**/*.key"
    - "**/secrets/**"
    - "**/.aws/credentials"
    - "**/.ssh/**"
    - "/etc/passwd"
    - "/etc/shadow"
    - "~/.ssh/**"
    - "~/.gnupg/**"

  # 敏感文件访问需要人工确认
  require_approval:
    - "config/database.yml"
    - "**/payment/**"
    - "**/billing/**"

commands:
  # 允许自动执行的命令（无需人工确认）
  allow_auto:
    - "ls"
    - "cat"
    - "grep"
    - "find"
    - "git status"
    - "git diff"
    - "git log"
    - "npm test"
    - "pytest"
    - "cargo test"

  # 需要人工确认才能执行的命令
  require_approval:
    - "git push"
    - "git commit"
    - "npm install"
    - "pip install"
    - "docker build"
    - "make deploy"

  # 绝对禁止执行的命令
  deny:
    - "rm -rf /"
    - "chmod 777"
    - "curl *"                  # 禁止任意网络请求
    - "wget *"
    - "nc *"                    # 禁止 netcat
    - "ncat *"
    - "ssh *"                   # 禁止 SSH 连接
    - "sudo *"                  # 禁止提权
    - "mkfs *"                  # 禁止格式化
    - "dd if=* of=/dev/*"      # 禁止磁盘写入
    - "eval *"                  # 禁止动态执行

network:
  # Claude Code 本身不应发起任意网络请求
  enabled: false

  # 如果确实需要，仅允许特定域名
  allow_domains:
    - "registry.npmjs.org"
    - "pypi.org"
    - "*.github.com"

  # 禁止访问的域名模式
  deny_domains:
    - "*.pastebin.com"
    - "*.transfer.sh"
    - "temp-*.*"

  # 代理配置（企业环境强制走代理）
  proxy:
    http: "http://proxy.corp.example.com:8080"
    https: "http://proxy.corp.example.com:8080"
    no_proxy: "localhost,127.0.0.1,.corp.example.com"

#!/bin/bash
# enforce-security-policy.sh - 部署前验证安全策略

POLICY_FILE=".claude/security-policy.yaml"

validate_policy() {
    echo "🔒 验证安全策略配置..."

    # 检查 deny 列表中是否包含关键路径
    if grep -q '"/etc/shadow"' "$POLICY_FILE"; then
        echo "  ✅ 系统敏感文件已列入禁止列表"
    else
        echo "  ❌ 缺少系统敏感文件保护"
        return 1
    fi

    # 检查是否禁止了危险命令
    if grep -q '"rm -rf /"' "$POLICY_FILE" && \
       grep -q '"sudo *"' "$POLICY_FILE"; then
        echo "  ✅ 危险命令已列入禁止列表"
    else
        echo "  ❌ 缺少危险命令保护"
        return 1
    fi

    # 检查网络策略
    if grep -q 'enabled: false' "$POLICY_FILE"; then
        echo "  ✅ 网络访问已禁用"
    else
        echo "  ⚠️ 网络访问未禁用，建议关闭"
    fi

    echo "✅ 安全策略验证通过"
}

validate_policy

项目根目录/
├── .claude/
│   └── CLAUDE.md              # 项目级规则（最高优先级）
├── CLAUDE.md                  # 仓库级规则
└── src/
    ├── CLAUDE.md              # 目录级规则
    └── api/
        └── CLAUDE.md          # 更细粒度的规则

<!-- /etc/claude-code/CLAUDE.md -->
# 企业全局规则

## 身份
你是由 {{ORGANIZATION_NAME}} IT 部门配置的 AI 编程助手。

## 语言与风格
- 代码注释使用中文
- 变量命名遵循 {{CODING_STANDARD}} 规范
- 所有公开 API 必须包含文档字符串

## 安全要求
- 永远不要在代码中硬编码密钥、密码或 Token
- 使用环境变量或密钥管理服务存储敏感信息
- 对用户输入进行严格的验证和转义
- 遵循最小权限原则

## 代码质量
- 每个函数必须有单元测试
- 避免使用已废弃的 API
- 错误处理必须具体，不能空 catch
- 日志输出必须包含上下文信息

## 合规要求
- 不得生成涉及个人信息处理的代码，除非已确认有合规审查
- 所有数据库查询必须使用参数化语句
- API 响应中不得包含内部实现细节
- 代码变更必须关联到具体的工单/Issue 编号

<!-- .claude/team/CLAUDE.md -->
# 后端团队规则

## 技术栈
- 语言: Python 3.11+
- 框架: FastAPI
- ORM: SQLAlchemy 2.0
- 测试: pytest + asyncio

## 编码规范
- 使用类型注解（所有函数签名必须有类型）
- 使用 pydantic 进行数据验证
- 异步函数统一使用 async/await，不混用同步代码
- 数据库操作必须在事务中执行

## 架构约定
- 控制器层只处理请求/响应，业务逻辑放在 service 层
- 每个 API 端点必须有对应的单元测试和集成测试
- 使用依赖注入，避免全局状态
- 日志使用结构化日志（JSON 格式）

## 安全约定
- 所有 API 端点默认需要认证
- 使用 JWT 进行身份验证，Token 有效期不超过 15 分钟
- 敏感操作需要二次验证
- 速率限制默认启用

<!-- payment-service/.claude/CLAUDE.md -->
# 支付服务 — 特殊安全规则

⚠️ 本项目处理支付数据，所有代码变更需经过安全团队审查。

## PCI-DSS 合规要求
- 不得存储完整的信用卡号（仅存储最后 4 位）
- 不得在日志中打印支付金额和用户信息
- 所有支付相关操作必须记录审计日志
- 支付 API 的响应时间不得暴露内部处理逻辑

## 代码变更要求
- 涉及支付逻辑的变更必须添加回归测试
- 金额计算使用 Decimal 类型，禁止使用 float
- 所有外部支付网关调用必须有超时和重试机制
- 幂等性：相同的支付请求不能重复扣款

## 审查要求
- 任何修改 payment/ 目录下代码的 PR 需要安全团队审批
- 涉及金额计算的变更需要财务团队复核

#!/usr/bin/env python3
"""CLAUDE.md 规则合并引擎 — 按优先级层级合并"""

import os
from pathlib import Path

RULE_PRIORITY = [
    "/etc/claude-code/CLAUDE.md",           # 1. 系统全局
    "~/.claude-code/CLAUDE.md",             # 2. 用户全局
    ".claude/team/CLAUDE.md",               # 3. 团队
    "CLAUDE.md",                            # 4. 仓库根目录
    ".claude/CLAUDE.md",                    # 5. 项目 .claude 目录
]

def merge_claud_md(project_root):
    """按优先级合并 CLAUDE.md 规则"""
    merged_sections = []

    for rule_path in RULE_PRIORITY:
        # 展开路径
        full_path = os.path.expandvars(
            os.path.expanduser(rule_path)
        )
        if not full_path.startswith("/"):
            full_path = os.path.join(project_root, full_path)

        if os.path.isfile(full_path):
            with open(full_path) as f:
                content = f.read().strip()

            if content:
                merged_sections.append(
                    f"<!-- Source: {rule_path} -->\n{content}"
                )

    # 合并输出
    output = "\n\n---\n\n".join(merged_sections)

    # 写入运行时的合并文件
    runtime_path = os.path.join(project_root, ".claude", "_merged_CLAUDE.md")
    with open(runtime_path, "w") as f:
        f.write(output)

    print(f"✅ 规则合并完成，共加载 {len(merged_sections)} 层")
    return runtime_path

if __name__ == "__main__":
    merge_claud_md(os.getcwd())

# .github/workflows/claude-rules-review.yml
name: CLAUDE.md 规则变更审查

on:
  pull_request:
    paths:
      - '**/CLAUDE.md'
      - '.claude/**'
      - '**/security-policy.yaml'

jobs:
  rules-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: 检测规则变更
        id: changes
        run: |
          RULES_CHANGED=$(git diff --name-only ${{ github.event.pull_request.base.sha }}..HEAD | \
            grep -E 'CLAUDE\.md|security-policy\.yaml' | wc -l)
          echo "count=$RULES_CHANGED" >> $GITHUB_OUTPUT

      - name: 安全规则变更 — 要求安全团队审批
        if: steps.changes.outputs.count > '0'
        run: |
          echo "⚠️ 检测到 Claude Code 规则变更"
          echo "📋 需要安全团队 @security-team 审批"
          echo "📋 需要工程团队 @eng-leads 审批"

          # 自动添加 reviewer
          gh pr edit ${{ github.event.pull_request.number }} \
            --add-reviewer security-team,eng-leads

      - name: 规则变更影响分析
        run: |
          git diff ${{ github.event.pull_request.base.sha }}..HEAD -- '**/CLAUDE.md' | \
            grep -E '^[-+]' | grep -v '^---' | grep -v '^\+\+\+'

      - name: 验证规则语法
        run: |
          # 确保 CLAUDE.md 没有语法错误
          for f in $(find . -name 'CLAUDE.md'); do
            echo "检查 $f ..."
            # 基本格式检查
            if ! grep -q '^#' "$f"; then
              echo "❌ $f 缺少标题"
              exit 1
            fi
          done

#!/bin/bash
# compliance-check.sh — Claude Code 代码变更合规审查

set -e

COMPLIANCE_REPORT="compliance-report-$(date +%Y%m%d_%H%M%S).json"

echo "🔍 开始合规审查..."

# 1. 检查敏感信息泄露
echo "  [1/6] 敏感信息扫描..."
if grep -rn --include="*.py" --include="*.js" --include="*.ts" \
    -E '(password|secret|api_key|token)\s*=\s*["\x27][^"\x27]{8,}' \
    src/ > /dev/null 2>&1; then
    echo "  ❌ 发现可能的硬编码敏感信息"
    COMPLIANCE_PASS=false
else
    echo "  ✅ 未发现硬编码敏感信息"
fi

# 2. 检查 SQL 注入风险
echo "  [2/6] SQL 注入风险扫描..."
if grep -rn --include="*.py" \
    -E '(execute|raw)\s*\(\s*f["\x27]|format\(|%\s)' \
    src/ > /dev/null 2>&1; then
    echo "  ❌ 发现可能的 SQL 注入风险"
    COMPLIANCE_PASS=false
else
    echo "  ✅ 未发现 SQL 注入风险"
fi

# 3. 检查类型注解覆盖率
echo "  [3/6] 类型注解检查..."
total_funcs=$(grep -rn "def " src/ --include="*.py" | wc -l)
typed_funcs=$(grep -rn "def.*->" src/ --include="*.py" | wc -l)
coverage=$((typed_funcs * 100 / total_funcs))
echo "  类型注解覆盖率: ${coverage}%"
if [ "$coverage" -lt 80 ]; then
    echo "  ⚠️ 覆盖率低于 80%，建议补充类型注解"
fi

# 4. 检查许可证头
echo "  [4/6] 许可证头检查..."
files_without_license=$(find src/ -name "*.py" -exec grep -L "Copyright\|License\|MIT\|Apache" {} \; | wc -l)
if [ "$files_without_license" -gt 0 ]; then
    echo "  ⚠️ $files_without_license 个文件缺少许可证头"
fi

# 5. 使用 Claude Code 进行深度合规审查
echo "  [5/6] AI 辅助合规审查..."
claude --bare \
    --max-turns 15 \
    --max-budget-usd 3 \
    --model haiku \
    --output-format stream-json \
    "
    进行合规审查，检查以下内容：
    1. 是否有潜在的个人信息处理（姓名、邮箱、电话、身份证号）
    2. 是否有未授权的数据访问
    3. 是否缺少必要的输入验证
    4. 错误信息是否暴露了内部实现细节

    审查范围：最近一次 commit 变更的文件
    " > "$COMPLIANCE_REPORT"

# 6. 生成报告
echo "  [6/6] 生成审查报告..."
echo "✅ 合规审查完成，报告: $COMPLIANCE_REPORT"

# .claude/compliance-rules.yaml
compliance:
  # 数据保护
  data_protection:
    pii_detection: true              # 自动检测个人信息
    data_classification: true        # 数据分类标记
    retention_policy: "90_days"      # 数据保留策略

  # 代码审计
  code_audit:
    require_code_review: true        # 强制代码审查
    require_security_review: true    # 安全团队审查
    minimum_reviewers: 2             # 最少审查人数
    auto_review_paths:               # 自动触发审查的路径
      - "src/payment/**"
      - "src/auth/**"
      - "src/user/**"

  # 许可证合规
  license:
    require_header: true             # 要求文件头
    allowed_licenses:                # 允许的开源许可证
      - "MIT"
      - "Apache-2.0"
      - "BSD-3-Clause"
    denied_licenses:                 # 禁止的许可证
      - "GPL-3.0"                    # 传染性许可证
      - "SSPL"

  # 审计要求
  audit:
    log_all_requests: true           # 记录所有 API 请求
    log_code_changes: true           # 记录代码变更
    log_review_actions: true         # 记录审查操作
    retention_period: "365_days"     # 审计日志保留期

#!/usr/bin/env python3
"""生成企业合规报告"""

import json
import os
from datetime import datetime

class ComplianceReporter:
    def __init__(self, project_root="."):
        self.project_root = project_root
        self.issues = []

    def scan_codebase(self):
        """扫描代码库中的合规问题"""
        # 敏感信息扫描
        self._scan_secrets()
        # PII 检测
        self._scan_pii()
        # 许可证检查
        self._scan_licenses()
        # 依赖安全检查
        self._scan_dependencies()

    def _scan_secrets(self):
        """扫描硬编码的密钥和密码"""
        import subprocess
        result = subprocess.run(
            ["grep", "-rn", "--include=*.py", "--include=*.js",
             "-E", r"(password|secret|api_key)\s*=\s*[\"'][^\"']{8,}",
             "src/"],
            capture_output=True, text=True
        )
        if result.returncode == 0:
            for line in result.stdout.strip().split("\n"):
                self.issues.append({
                    "type": "hardcoded_secret",
                    "severity": "high",
                    "location": line.split(":")[0],
                    "description": f"可能的硬编码敏感信息: {line}"
                })

    def generate_report(self):
        """生成 JSON 格式的合规报告"""
        report = {
            "timestamp": datetime.now().isoformat(),
            "project": os.path.basename(os.path.abspath(self.project_root)),
            "total_issues": len(self.issues),
            "summary": {
                "high": len([i for i in self.issues if i["severity"] == "high"]),
                "medium": len([i for i in self.issues if i["severity"] == "medium"]),
                "low": len([i for i in self.issues if i["severity"] == "low"]),
            },
            "issues": self.issues
        }

        report_path = f"compliance-report-{datetime.now():%Y%m%d}.json"
        with open(report_path, "w") as f:
            json.dump(report, f, indent=2)

        print(f"📋 合规报告已生成: {report_path}")
        print(f"   高优先级: {report['summary']['high']}")
        print(f"   中优先级: {report['summary']['medium']}")
        print(f"   低优先级: {report['summary']['low']}")

        return report

if __name__ == "__main__":
    reporter = ComplianceReporter()
    reporter.scan_codebase()
    reporter.generate_report()

┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────────┐
│ Developer │────▶│ Claude   │────▶│ SSO      │────▶│ Identity     │
│ (CLI)    │     │ Code     │     │ Proxy    │     │ Provider     │
│          │◀────│          │◀────│          │◀────│ (Okta/AD/etc)│
└──────────┘     └──────────┘     └──────────┘     └──────────────┘
     │                                  │
     │ Token                            │ SAML/OIDC
     │                                  │
     ▼                                  ▼
┌──────────┐                    ┌──────────────┐
│Anthropic  │                    │  Group/Role  │
│ API      │                    │  Mapping     │
└──────────┘                    └──────────────┘

#!/bin/bash
# setup-okta-sso.sh - Claude Code 与 Okta SSO 集成

OKTA_ORG="mycompany.okta.com"
OKTA_APP_ID="0oa1234567890abcdef"

echo "🔐 配置 Claude Code SSO (Okta)..."

# 1. 配置 Okta OIDC 应用
# 在 Okta Admin Console 中创建 OIDC 应用
# 配置：
#   - Application type: Native App
#   - Grant type: Authorization Code + PKCE
#   - Sign-in redirect URI: http://localhost:7777/auth/callback
#   - Sign-out redirect URI: http://localhost:7777/auth/logout
#   - Trusted Origins: http://localhost:7777

# 2. 配置 Claude Code 使用 Okta
cat > ~/.claude-code/sso-config.json << EOF
{
    "sso": {
        "provider": "okta",
        "issuer": "https://${OKTA_ORG}/oauth2/default",
        "client_id": "${OKTA_APP_ID}",
        "redirect_uri": "http://localhost:7777/auth/callback",
        "scopes": ["openid", "profile", "email", "groups"],
        "group_mapping": {
            "claude-code-admins": ["admin", "full-access"],
            "claude-code-developers": ["developer", "standard-access"],
            "claude-code-reviewers": ["reviewer", "read-only"]
        }
    }
}
EOF

echo "✅ Okta SSO 配置完成"
echo "   运行 'claude auth login --sso' 开始使用 SSO 登录"

#!/bin/bash
# setup-azure-ad-sso.sh - Claude Code 与 Azure AD 集成

AZURE_TENANT_ID="your-tenant-id"
AZURE_CLIENT_ID="your-client-id"

cat > ~/.claude-code/sso-config.json << EOF
{
    "sso": {
        "provider": "azure-ad",
        "tenant_id": "${AZURE_TENANT_ID}",
        "client_id": "${AZURE_CLIENT_ID}",
        "authority": "https://login.microsoftonline.com/${AZURE_TENANT_ID}",
        "redirect_uri": "http://localhost:7777/auth/callback",
        "scopes": ["openid", "profile", "email", "User.Read"],
        "group_mapping": {
            "Engineering-Team": ["developer", "standard-access"],
            "Security-Team": ["reviewer", "security-access"],
            "IT-Admins": ["admin", "full-access"]
        }
    }
}
EOF

echo "✅ Azure AD SSO 配置完成"

#!/bin/bash
# setup-keycloak-sso.sh - Claude Code 与 Keycloak 集成

KEYCLOAK_URL="https://keycloak.corp.example.com"
KEYCLOAK_REALM="claude-code"
KEYCLOAK_CLIENT_ID="claude-code-cli"

cat > ~/.claude-code/sso-config.json << EOF
{
    "sso": {
        "provider": "keycloak",
        "issuer": "${KEYCLOAK_URL}/realms/${KEYCLOAK_REALM}",
        "client_id": "${KEYCLOAK_CLIENT_ID}",
        "redirect_uri": "http://localhost:7777/auth/callback",
        "scopes": ["openid", "profile", "email", "groups"],
        "group_claim": "groups",
        "group_mapping": {
            "/developers": ["developer", "standard-access"],
            "/security-reviewers": ["reviewer", "security-access"],
            "/admins": ["admin", "full-access"]
        }
    }
}
EOF

echo "✅ Keycloak SSO 配置完成"

#!/usr/bin/env python3
"""SSO Token 管理与自动续期"""

import json
import time
import subprocess
from datetime import datetime
from pathlib import Path

class SSOTokenManager:
    def __init__(self, config_path="~/.claude-code/sso-config.json"):
        self.config_path = Path(config_path).expanduser()
        self.token_path = Path("~/.claude-code/sso-token.json").expanduser()

    def load_config(self):
        with open(self.config_path) as f:
            return json.load(f)

    def is_token_valid(self):
        """检查 Token 是否有效"""
        if not self.token_path.exists():
            return False

        with open(self.token_path) as f:
            token_data = json.load(f)

        expires_at = token_data.get("expires_at", 0)
        # 提前 5 分钟续期
        return time.time() < expires_at - 300

    def refresh_token(self):
        """刷新 Token"""
        config = self.load_config()
        provider = config["sso"]["provider"]

        if provider == "okta":
            self._refresh_okta(config["sso"])
        elif provider == "azure-ad":
            self._refresh_azure_ad(config["sso"])
        elif provider == "keycloak":
            self._refresh_keycloak(config["sso"])

    def _refresh_okta(self, sso_config):
        """Okta Token 刷新"""
        # 使用 Okta CLI 或 OAuth 刷新流程
        result = subprocess.run(
            ["okta", "login", "--org", sso_config["issuer"]],
            capture_output=True, text=True
        )
        if result.returncode == 0:
            print("✅ Okta Token 刷新成功")
            self._save_token(result.stdout)

    def _save_token(self, token_data):
        """保存 Token 到本地"""
        data = {
            "token": token_data,
            "refreshed_at": time.time(),
            "expires_at": time.time() + 3600  # 1 小时有效期
        }
        with open(self.token_path, "w") as f:
            json.dump(data, f, indent=2)
        self.token_path.chmod(0o600)  # 仅所有者可读写

    def check_and_refresh(self):
        """检查并在需要时刷新 Token"""
        if not self.is_token_valid():
            print("🔄 SSO Token 即将过期，正在刷新...")
            self.refresh_token()
        else:
            print("✅ SSO Token 有效")

if __name__ == "__main__":
    manager = SSOTokenManager()
    manager.check_and_refresh()

# .claude/rbac-policy.yaml
roles:
  admin:
    permissions:
      - "model:*"                    # 可使用所有模型
      - "budget:*"                   # 无预算限制
      - "config:write"               # 可修改配置
      - "security:read"              # 可查看安全策略
      - "audit:read"                 # 可查看审计日志
    max_budget_usd: null             # 无限制
    allowed_models: ["opus", "sonnet", "haiku"]

  developer:
    permissions:
      - "model:sonnet"
      - "model:haiku"
      - "budget:daily:10"            # 每日 10 美元
      - "config:read"
    max_budget_usd: 10
    allowed_models: ["sonnet", "haiku"]

  reviewer:
    permissions:
      - "model:sonnet"
      - "model:haiku"
      - "budget:daily:5"
      - "config:read"
      - "review:write"               # 可提交审查意见
    max_budget_usd: 5
    allowed_models: ["sonnet", "haiku"]

  intern:
    permissions:
      - "model:haiku"
      - "budget:daily:2"
      - "config:read"
    max_budget_usd: 2
    allowed_models: ["haiku"]
    # 实习生只能使用 Haiku，且需要监督
    require_supervisor_approval: true

Claude Code CLI
    │
    ├── 每次 API 调用 ──▶ 审计日志 (JSONL)
    │                      ├── timestamp
    │                      ├── user_id
    │                      ├── action (read/write/exec/review)
    │                      ├── resource (file path / command)
    │                      ├── model_used
    │                      ├── tokens_consumed
    │                      ├── cost_usd
    │                      └── approval_status
    │
    └── 配置变更 ──▶ 审计日志
                       ├── config_change
                       ├── old_value
                       ├── new_value
                       └── changed_by

# .claude/audit-config.yaml
audit:
  enabled: true

  # 日志输出位置
  output:
    - type: "file"
      path: "~/.claude-code/audit-log.jsonl"
      max_size_mb: 100
      rotate: true

    - type: "syslog"
      facility: "local0"
      server: "syslog.corp.example.com"
      port: 514

    - type: "http"
      endpoint: "https://audit-api.corp.example.com/v1/claude-events"
      batch_size: 50
      flush_interval_seconds: 30

  # 记录的事件类型
  events:
    - api_call           # API 调用
    - file_read          # 文件读取
    - file_write         # 文件写入
    - command_exec       # 命令执行
    - config_change      # 配置变更
    - auth_event         # 认证事件
    - policy_violation   # 策略违规
    - budget_warning     # 预算预警

  # 隐私保护
  privacy:
    mask_secrets: true                # 自动脱敏
    exclude_patterns:                 # 不记录的内容
      - "**/password**"
      - "**/token**"
      - "**/secret**"
    retention_days: 365               # 日志保留期

#!/bin/bash
# claude-monitor.sh - 实时监控 Claude Code 使用情况

AUDIT_LOG="${CLAUDE_CODE_HOME:-~/.claude-code}/audit-log.jsonl"

# 实时活跃用户
echo "👥 当前活跃用户 (最近 1 小时):"
jq -r 'select(.timestamp > (now - 3600)) | .user_id' "$AUDIT_LOG" | \
    sort | uniq -c | sort -rn | head -10

echo ""

# Token 消耗排行
echo "🔥 Top 5 Token 消耗用户:"
jq -r '[.user_id, .tokens_consumed] | @tsv' "$AUDIT_LOG" | \
    awk '{users[$1]+=$2} END {for (u in users) print users[u], u}' | \
    sort -rn | head -5 | \
    while read tokens user; do
        printf "  %s: %'d tokens\n" "$user" "$tokens"
    done

echo ""

# 策略违规事件
echo "🚨 最近策略违规:"
jq -r 'select(.event == "policy_violation") | [.timestamp, .user_id, .details] | @tsv' \
    "$AUDIT_LOG" | tail -5

echo ""

# API 调用频率
echo "📊 API 调用频率 (最近 24 小时):"
jq -r 'select(.event == "api_call") | .timestamp' "$AUDIT_LOG" | \
    awk '{hour=strftime("%H", $1); counts[hour]++} END {for (h in counts) print h, counts[h]}' | \
    sort | \
    while read hour count; do
        bar=$(printf '█%.0s' $(seq 1 $((count / 5))))
        printf "  %s:00 | %s (%d)\n" "$hour" "$bar" "$count"
    done

## Claude Code 企业部署检查清单

### Phase 1: 基础设施准备
- [ ] 确定 SSO 提供商（Okta / Azure AD / Keycloak）
- [ ] 配置网络代理（如需要）
- [ ] 设置 API Key 集中管理
- [ ] 准备审计日志存储

### Phase 2: 安全策略
- [ ] 制定文件系统访问策略
- [ ] 制定命令执行策略
- [ ] 制定网络访问策略
- [ ] 配置数据泄露防护 (DLP)

### Phase 3: 规则配置
- [ ] 编写全局 CLAUDE.md 规则
- [ ] 编写团队级 CLAUDE.md 规则
- [ ] 编写项目级 CLAUDE.md 规则
- [ ] 设置规则合并与版本控制流程

### Phase 4: 成本管控
- [ ] 设置全局预算上限
- [ ] 配置角色预算配额
- [ ] 配置模型降级策略
- [ ] 设置成本监控告警

### Phase 5: 合规审查
- [ ] 配置自动化合规检查
- [ ] 设置合规审查工作流
- [ ] 配置合规报告生成
- [ ] 建立合规审批流程

### Phase 6: 用户培训与上线
- [ ] 编写用户使用手册
- [ ] 进行安全培训
- [ ] 小范围试点（5-10 人）
- [ ] 收集反馈并优化
- [ ] 全量推广

#!/bin/bash
# deploy-claude-enterprise.sh — 企业级一键部署

set -e

echo "🚀 Claude Code 企业部署"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

# 参数
ORG_NAME="${ORG_NAME:-MyCompany}"
SSO_PROVIDER="${SSO_PROVIDER:-okta}"
TEAM="${TEAM:-backend}"
ADMIN_EMAIL="${ADMIN_EMAIL:-admin@$ORG_NAME}"

# 1. 创建配置目录
echo ""
echo "📁 [1/6] 创建配置目录..."
mkdir -p ~/.claude-code/{team,audit,cache}

# 2. 部署安全策略
echo "🔒 [2/6] 部署安全策略..."
cat > ~/.claude-code/security-policy.yaml << 'EOF'
# 企业安全策略
filesystem:
  deny:
    - ".env*"
    - "**/*.pem"
    - "**/*.key"
    - "**/secrets/**"
    - "~/.ssh/**"
commands:
  deny:
    - "rm -rf /"
    - "sudo *"
    - "ssh *"
    - "curl *"
network:
  enabled: false
EOF
echo "  ✅ 安全策略已部署"

# 3. 部署全局规则
echo "📋 [3/6] 部署全局规则..."
cat > ~/.claude-code/CLAUDE.md << EOF
# $ORG_NAME 全局规则
## 身份
你是由 $ORG_NAME IT 部门配置的 AI 编程助手。
## 安全要求
- 不得硬编码密钥
- 使用环境变量管理敏感配置
- 遵循最小权限原则
## 代码质量
- 所有函数必须有类型注解
- 每个公开 API 必须有文档
- 错误处理必须具体
EOF
echo "  ✅ 全局规则已部署"

# 4. 配置 SSO
echo "🔐 [4/6] 配置 SSO ($SSO_PROVIDER)..."
cat > ~/.claude-code/sso-config.json << EOF
{
    "sso": {
        "provider": "$SSO_PROVIDER",
        "auto_refresh": true,
        "refresh_before_expiry_seconds": 300
    }
}
EOF
echo "  ✅ SSO 配置已部署"

# 5. 配置审计
echo "📊 [5/6] 配置审计..."
cat > ~/.claude-code/audit-config.yaml << 'EOF'
audit:
  enabled: true
  output:
    - type: "file"
      path: "~/.claude-code/audit-log.jsonl"
  events:
    - api_call
    - file_read
    - file_write
    - command_exec
    - policy_violation
EOF
echo "  ✅ 审计配置已部署"

# 6. 验证部署
echo "🧪 [6/6] 验证部署..."
errors=0

for file in security-policy.yaml CLAUDE.md sso-config.json audit-config.yaml; do
    if [ -f "$HOME/.claude-code/$file" ]; then
        echo "  ✅ $file"
    else
        echo "  ❌ $file 缺失"
        errors=$((errors + 1))
    fi
done

echo ""
if [ $errors -eq 0 ]; then
    echo "🎉 部署完成！所有组件验证通过。"
    echo ""
    echo "下一步："
    echo "  1. 运行 'claude auth login --sso' 进行 SSO 登录"
    echo "  2. 运行 'claude --bare \"Hello\"' 测试基本功能"
    echo "  3. 联系管理员获取团队配置同步脚本"
else
    echo "⚠️ 部署完成，但有 $errors 个问题需要处理"
    exit 1
fi