hsuehic/mcp-credentials-server

# Install the package globally
npm install -g mcp-credentials-server

# Or clone and build from source
git clone https://github.com/hsuehic/mcp-credentials-server.git
cd mcp-credentials-server
npm install
npm run build

{
  "mcpServers": {
    "mcp-credentials-server": {
      "command": "mcp-credentials-server"
    }
  }
}

{
  "mcpServers": {
    "mcp-credentials-server": {
      "command": "mcp-credentials-server",
      "env": {
        "MCP_ENCRYPTION_KEY": "your-32-character-encryption-key-here",
        "NODE_ENV": "production"
      }
    }
  }
}

{
  "mcpServers": {
    "mcp-credentials-server": {
      "command": "npx",
      "args": ["mcp-credentials-server"],
      "env": {
        "MCP_ENCRYPTION_KEY": "your-32-character-encryption-key-here",
        "NODE_ENV": "production"
      }
    }
  }
}

{
  "mcpServers": {
    "mcp-credentials-server": {
      "command": "node",
      "args": ["/path/to/mcp-credentials-server/dist/server/index.js"],
      "env": {
        "MCP_ENCRYPTION_KEY": "your-32-character-encryption-key-here",
        "MCP_DEBUG": "true",
        "NODE_ENV": "development"
      }
    }
  }
}

# Generate a secure 32-character encryption key
node -e "console.log(require('crypto').randomBytes(16).toString('hex'));"

# Or use openssl
openssl rand -hex 16

# Example output: a1b2c3d4e5f6789012345678901234ab

# Test zero-config setup
mcp-credentials-server
# On first run, you'll see: "🔑 Generated new encryption key and saved to: ~/.mcp-credentials/.encryption-key"

# Test with custom key
NODE_ENV=production MCP_ENCRYPTION_KEY=your-key-here mcp-credentials-server

# You should see: "🚀 MCP Credentials Server started successfully"
# Press Ctrl+C to stop the test

// AI Agent简单调用
const credentials = await mcpCall('get_credentials', {
  service: 'linkedin',
  include2FA: true, // 自动处理2FA
});

// 自动获得登录信息和2FA代码
console.log(credentials.data.email); // 登录邮箱
console.log(credentials.twoFactorCode); // 自动生成的2FA代码

// 存储TOTP secret，自动生成验证码
{
  service: 'linkedin',
  twoFactor: {
    type: '2fa_totp',
    totpSecret: 'JBSWY3DPEHPK3PXP',  // 扫码获得的secret
    isActive: true
  }
}

// AI Agent自动获得6位验证码
const code = await mcpCall('generate_2fa', { service: 'linkedin' });
// 返回: { code: '123456', timeRemaining: 25 }

// 预存储备用验证码
{
  twoFactor: {
    type: '2fa_backup',
    backupCodes: ['12345678', '23456789', '34567890'],
    isActive: true
  }
}

// 自动使用并移除已用代码
const result = await mcpCall('generate_2fa', { service: 'github' });
// 返回: { code: '12345678', codesRemaining: 2 }

// 某些服务支持应用专用密码（如GitHub）
{
  twoFactor: {
    type: '2fa_app_password',
    appPassword: 'ghp_xxxxxxxxxxxxxxxxxxxx',
    isActive: true
  }
}

// AI Agent直接使用应用密码，无需2FA

// 保持长期有效的登录会话
{
  twoFactor: {
    type: '2fa_session_persist',
    sessionCookies: ['session=xxx', 'token=yyy'],
    isActive: true
  }
}

npm install @xiaoweihsueh/mcp-credentials-server

import { MCPCredentialsServer } from '@xiaoweihsueh/mcp-credentials-server';

const server = new MCPCredentialsServer({
  port: 3000,
  storage: {
    storePath: '~/.mcp-credentials',
    encryptionKey: process.env.MCP_ENCRYPTION_KEY,
  },
  supported2FA: ['auto_totp', 'backup_codes', 'app_password'],
  debug: true,
});

await server.start();

// 设置LinkedIn凭据（带2FA）
await mcpCall('set_credentials', {
  service: 'linkedin',
  credentials: {
    email: 'your@email.com',
    password: 'your-password',
    twoFactor: {
      type: '2fa_totp',
      totpSecret: 'JBSWY3DPEHPK3PXP', // 从LinkedIn 2FA设置获得
      isActive: true,
    },
  },
});

// 设置GitHub凭据（应用密码）
await mcpCall('set_credentials', {
  service: 'github',
  credentials: {
    token: 'ghp_xxxxxxxxxxxxxxxxxxxx',
    username: 'your-username',
    twoFactor: {
      type: '2fa_app_password',
      appPassword: 'ghp_xxxxxxxxxxxxxxxxxxxx',
      isActive: true,
    },
  },
});

const result = await mcpCall('get_credentials', {
  service: 'linkedin',
  profile: 'work',        // 可选，默认'default'
  include2FA: true        // 可选，是否生成2FA代码
});

// 返回
{
  success: true,
  data: {
    service: 'linkedin',
    email: 'your@email.com',
    password: 'your-password',
    twoFactor: { ... }
  },
  twoFactorCode: '123456',  // 自动生成的2FA代码
  timestamp: '2025-10-10T12:00:00.000Z'
}

await mcpCall('set_credentials', {
  service: 'postgres',
  credentials: {
    host: 'localhost',
    port: 5432,
    username: 'admin',
    password: 'secret',
    database: 'mydb',
  },
  profile: 'production',
});

const result = await mcpCall('generate_2fa', {
  service: 'linkedin',
  profile: 'work'
});

// 返回
{
  success: true,
  code: '123456',
  codesRemaining: 5,      // 如果使用备用代码
  nextCodeIn: 25,         // TOTP下次更新秒数
  timestamp: '2025-10-10T12:00:00.000Z'
}

const result = await mcpCall('validate_credentials', {
  service: 'linkedin'
});

// 返回
{
  success: true,
  valid: true,
  details: {
    requiredFields: ['email', 'password'],
    missingFields: [],
    has2FA: true,
    lastUpdated: '2025-10-10T12:00:00.000Z'
  }
}

const result = await mcpCall('list_services', {
  profile: 'work'
});

// 返回
{
  services: ['linkedin', 'github', 'postgres'],
  count: 3,
  timestamp: '2025-10-10T12:00:00.000Z'
}

{
  service: 'linkedin',
  email: 'your-email@example.com',
  password: 'your-linkedin-password',
  twoFactor: {
    type: '2fa_totp',
    totpSecret: 'JBSWY3DPEHPK3PXP2Q4B7Z8A9C1D2E3F',
    isActive: true
  }
}

{
  "success": true,
  "data": {
    "email": "your-email@example.com",
    "password": "your-linkedin-password",
    "twoFactor": { "type": "2fa_totp", "isActive": true }
  },
  "twoFactorCode": "123456",
  "timestamp": "2025-10-10T12:00:00.000Z"
}

class LinkedInAgent {
  async postUpdate(message: string) {
    // 1. 获取凭据和2FA代码
    const creds = await mcpCall('get_credentials', {
      service: 'linkedin',
      include2FA: true,
    });

    // 2. 自动登录（集成Chrome DevTools MCP）
    await browser.navigate('https://linkedin.com/login');
    await browser.fill('#username', creds.data.email);
    await browser.fill('#password', creds.data.password);
    await browser.click('button[type="submit"]');

    // 3. 处理2FA（如果需要）
    if (creds.twoFactorCode) {
      await browser.fill('input[name="pin"]', creds.twoFactorCode);
      await browser.click('button[type="submit"]');
    }

    // 4. 发布帖子
    await browser.click('[data-test-id="share-box-trigger"]');
    await browser.fill('[data-test-id="share-box-text-area"]', message);
    await browser.click('[data-test-id="share-button"]');

    console.log('✅ LinkedIn帖子发布成功!');
  }
}

class DatabaseAgent {
  async queryData(sql: string) {
    // 获取数据库凭据
    const creds = await mcpCall('get_credentials', {
      service: 'postgres',
      profile: 'production',
    });

    // 连接数据库
    const client = new pg.Client({
      host: creds.data.host,
      port: creds.data.port,
      user: creds.data.username,
      password: creds.data.password,
      database: creds.data.database,
      ssl: creds.data.ssl,
    });

    await client.connect();
    const result = await client.query(sql);
    await client.end();

    return result.rows;
  }
}

class ProjectWorkflow {
  async publishWeeklyReport() {
    // 1. 从数据库获取项目数据
    const projectData = await this.databaseAgent.queryData(`
      SELECT * FROM project_metrics
      WHERE date >= CURRENT_DATE - INTERVAL 7 DAYS
    `);

    // 2. 生成报告内容
    const report = this.generateReport(projectData);

    // 3. 发布到LinkedIn
    await this.linkedinAgent.postUpdate(report);

    // 4. 同步到GitHub Issues
    await this.githubAgent.createIssue('Weekly Report', report);

    console.log('✅ 周报发布工作流完成!');
  }
}

// Agent权限控制
const agentContext = {
  agentId: 'marketing-bot',
  permissions: ['linkedin', 'twitter'], // 只能访问社交媒体
  sessionId: 'session-xxx',
};

// 完整的操作审计
{
  id: 'audit-xxx',
  timestamp: '2025-10-10T12:00:00.000Z',
  action: 'get_credentials',
  service: 'linkedin',
  agentContext: { agentId: 'marketing-bot' },
  success: true,
  metadata: { profile: 'work' }
}

// 自动备份配置
{
  backupEnabled: true,
  backupInterval: 60,        // 60分钟
  retention: 10              // 保留10个备份
}

interface MCPServerConfig {
  port?: number; // 服务端口，默认3000
  host?: string; // 服务地址，默认localhost
  storage: {
    storePath?: string; // 存储路径，默认~/.mcp-credentials
    encryptionKey?: string; // 加密密钥
    backupEnabled?: boolean; // 是否启用备份
    backupInterval?: number; // 备份间隔（分钟）
  };
  supported2FA?: string[]; // 支持的2FA策略
  sessionTimeout?: number; // 会话超时（分钟）
  debug?: boolean; // 调试模式
}

// 结合浏览器自动化
const browser = new ChromeDevToolsMCP();
const credentials = new MCPCredentialsServer();

// 自动化登录流程
async function autoLogin(service: string) {
  const creds = await credentials.getCredentials(service);

  await browser.navigate(getLoginURL(service));
  await browser.fill('#username', creds.data.email);
  await browser.fill('#password', creds.data.password);

  if (creds.twoFactorCode) {
    await browser.fill('#totp', creds.twoFactorCode);
  }

  await browser.click('#login-button');
}

// 自动发布文档
async function publishToConfluence(title: string, content: string) {
  const creds = await mcpCall('get_credentials', {
    service: 'confluence',
  });

  await confluenceMCP.authenticate(creds.data);
  await confluenceMCP.createPage(title, content);
}

const status = server.getStatus();
console.log(status);
// {
//   version: '1.0.0',
//   uptime: 3600,
//   stats: {
//     auditLogsCount: 150,
//     lastActivity: '2025-10-10T12:00:00.000Z'
//   }
// }

const stats = await storage.getStats();
console.log(stats);
// {
//   profiles: 3,
//   totalServices: 12,
//   storageSize: 4096,
//   backupCount: 7
// }