oadmin/cursornew2026
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

CursorPro 后台管理系统 v1.0

Browse Source 
功能:
- 激活码管理 (Pro/Auto 两种类型)
- 账号池管理
- 设备绑定记录
- 使用日志
- 搜索/筛选功能
- 禁用/启用功能 (支持退款参考)
- 全局设置 (换号间隔、额度消耗等)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
ccdojox-crypto
2025-12-16 20:54:44 +08:00
commit 9e2333c90c
62 changed files with 9567 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
deobfuscated_full/ANALYSIS.md Normal file
View File

@@ -0,0 +1,120 @@
# CursorPro 反混淆分析报告
## 项目结构
```
deobfuscated/
├── extension.js # 扩展主入口
├── api/
│ └── client.js # API 客户端
├── utils/
│ ├── account.js # 账号管理工具
│ └── sqlite.js # SQLite 数据库操作
└── webview/
└── provider.js # Webview 提供者
```
## 功能分析
### 1. extension.js - 扩展入口
- **cleanServiceWorkerCache()**: 清理 Cursor 的 Service Worker 缓存
- **activate()**: 注册 webview provider 和状态栏
- **updateUsageStatusBar()**: 更新状态栏显示使用量
### 2. api/client.js - API 客户端
与远程服务器通信，主要 API：
| 函数 | 端点 | 说明 |
|------|------|------|
| `verifyKey()` | POST /api/verify | 验证激活码 |
| `switchAccount()` | POST /api/switch | 切换账号 |
| `getSeamlessStatus()` | GET /api/seamless/status | 获取无缝模式状态 |
| `injectSeamless()` | POST /api/seamless/inject | 注入无缝模式 |
| `getProxyConfig()` | GET /api/proxy-config | 获取代理配置 |
**默认 API 服务器**: `https://api.cursorpro.com` (从混淆代码中提取)
### 3. utils/account.js - 账号管理
**getCursorPaths()** - 返回 Cursor 配置路径：
| 平台 | 数据库路径 |
|------|-----------|
| Windows | `%APPDATA%/Cursor/User/globalStorage/state.vscdb` |
| macOS | `~/Library/Application Support/Cursor/User/globalStorage/state.vscdb` |
| Linux | `~/.config/Cursor/User/globalStorage/state.vscdb` |
**writeAccountToLocal()** - 写入账号数据到本地：
- 修改 SQLite 数据库中的认证 token
- 更新 storage.json 中的设备 ID
- 写入 machineid 文件
- Windows: 写入注册表
**关键数据库字段**：
```
cursorAuth/accessToken - 访问令牌
cursorAuth/refreshToken - 刷新令牌
cursorAuth/WorkosCursorSessionToken - WorkOS 会话令牌
cursorAuth/cachedEmail - 缓存邮箱
cursorAuth/stripeMembershipType - 会员类型
telemetry.serviceMachineId - 服务机器ID
telemetry.devDeviceId - 设备ID
```
### 4. utils/sqlite.js - SQLite 操作
通过 `sqlite3` 命令行工具直接操作 Cursor 的 VSCode 状态数据库：
- `sqliteGet()` - 读取单个值
- `sqliteSet()` - 写入单个值
- `sqliteSetBatch()` - 批量写入 (使用事务)
### 5. webview/provider.js - Webview 界面
实现侧边栏 UI，提供：
- 激活码验证界面
- 使用统计显示
- 无缝模式配置
- 代理设置
- 账号切换功能
## 工作原理
```
┌─────────────────────────────────────────────────────────────┐
│ CursorPro 工作流程 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 1. 用户输入激活码 │
│ ↓ │
│ 2. 发送到远程 API 服务器验证 │
│ ↓ │
│ 3. 服务器返回账号数据 (token, email, 设备ID等) │
│ ↓ │
│ 4. 写入本地 Cursor 配置文件: │
│ - state.vscdb (SQLite 数据库) │
│ - storage.json │
│ - machineid │
│ ↓ │
│ 5. 提示重启 Cursor 生效 │
│ │
└─────────────────────────────────────────────────────────────┘
```
## 安全风险分析
1. **远程服务器控制**: 所有账号数据来自 `api.cursorpro.com`
2. **本地文件修改**: 直接操作 Cursor 数据库和配置文件
3. **设备指纹伪造**: 替换 machineId, devDeviceId 等标识
4. **进程控制**: 可强制关闭 Cursor 进程
## 混淆技术分析
原代码使用了以下混淆技术：
1. **字符串数组 + 解密函数**: 所有字符串存储在数组中，通过 RC4 算法解密
2. **十六进制变量名**: `_0x50c5e9`, `_0x2b0b` 等
3. **控制流平坦化**: 使用 switch-case 打乱代码执行顺序
4. **死代码注入**: 插入无用的条件分支
5. **Base64 + RC4 双重编码**: 字符串先 Base64 再 RC4 加密
---
*此分析仅供安全研究和学习目的*

257
deobfuscated_full/api/client.js Normal file
View File

@@ -0,0 +1,257 @@
'use strict';
// ============================================
// CursorPro API Client - 反混淆版本
// ============================================
const vscode = require('vscode');
// 默认 API 地址 (原代码中被混淆)
const DEFAULT_API_URL = 'https://api.cursorpro.com';
const REQUEST_TIMEOUT = 15000; // 15秒超时
let isOnline = true;
let onlineStatusCallbacks = [];
/**
* 获取 API URL (从配置或使用默认值)
*/
function getApiUrl() {
const config = vscode.workspace.getConfiguration('cursorpro');
return config.get('apiUrl') || DEFAULT_API_URL;
}
exports.getApiUrl = getApiUrl;
/**
* 获取在线状态
*/
function getOnlineStatus() {
return isOnline;
}
exports.getOnlineStatus = getOnlineStatus;
/**
* 监听在线状态变化
*/
function onOnlineStatusChange(callback) {
onlineStatusCallbacks.push(callback);
return () => {
onlineStatusCallbacks = onlineStatusCallbacks.filter(cb => cb !== callback);
};
}
exports.onOnlineStatusChange = onOnlineStatusChange;
/**
* 设置在线状态
*/
function setOnlineStatus(status) {
if (isOnline !== status) {
isOnline = status;
onlineStatusCallbacks.forEach(callback => callback(status));
}
}
/**
* 带超时的 fetch
*/
async function fetchWithTimeout(url, options, timeout) {
const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), timeout);
try {
const response = await fetch(url, {
...options,
signal: controller.signal
});
clearTimeout(timeoutId);
return response;
} catch (error) {
clearTimeout(timeoutId);
throw error;
}
}
/**
* 通用请求函数
*/
async function request(endpoint, method = 'GET', body) {
const url = `${getApiUrl()}${endpoint}`;
const options = {
method: method,
headers: {
'Content-Type': 'application/json'
}
};
if (body) {
options.body = JSON.stringify(body);
}
try {
const response = await fetchWithTimeout(url, options, REQUEST_TIMEOUT);
const data = await response.json();
setOnlineStatus(true);
if (!response.ok && data.error) {
data.success = false;
data.message = data.error;
}
return data;
} catch (error) {
// 检查是否是网络错误
const isNetworkError = error.name === 'AbortError' ||
error.name === 'fetch' ||
error.message?.includes('network') ||
error.message?.includes('fetch') ||
error.message?.includes('ENOTFOUND') ||
error.message?.includes('ETIMEDOUT') ||
error.message?.includes('ECONNREFUSED');
if (isNetworkError) {
setOnlineStatus(false);
return {
success: false,
error: '网络连接失败，请检查网络',
isOffline: true
};
}
throw error;
}
}
/**
* 验证 Key
*/
async function verifyKey(key) {
return request('/api/verify', 'POST', { key });
}
exports.verifyKey = verifyKey;
/**
* 切换账号
*/
async function switchAccount(key) {
return request('/api/switch', 'POST', { key });
}
exports.switchAccount = switchAccount;
/**
* 获取代理配置
*/
async function getProxyConfig() {
return request('/api/proxy-config', 'GET');
}
exports.getProxyConfig = getProxyConfig;
/**
* 更新代理配置
*/
async function updateProxyConfig(isEnabled, proxyUrl) {
return request('/api/proxy-config', 'POST', {
is_enabled: isEnabled,
proxy_url: proxyUrl
});
}
exports.updateProxyConfig = updateProxyConfig;
// ============================================
// 无感换号 (Seamless Mode) API
// ============================================
/**
* 获取无缝模式状态
* 检查用户是否有权使用无感换号功能
*/
async function getSeamlessStatus() {
return request('/api/seamless/status');
}
exports.getSeamlessStatus = getSeamlessStatus;
/**
* 获取用户切换状态
*/
async function getUserSwitchStatus(userKey) {
return request('/api/seamless/user-status?key=' + encodeURIComponent(userKey));
}
exports.getUserSwitchStatus = getUserSwitchStatus;
/**
* 获取无缝配置
*/
async function getSeamlessConfig() {
return request('/api/seamless/config');
}
exports.getSeamlessConfig = getSeamlessConfig;
/**
* 更新无缝配置
*/
async function updateSeamlessConfig(config) {
return request('/api/seamless/config', 'POST', config);
}
exports.updateSeamlessConfig = updateSeamlessConfig;
/**
* 注入无缝模式
*/
async function injectSeamless(apiUrl, userKey) {
return request('/api/seamless/inject', 'POST', {
api_url: apiUrl,
user_key: userKey
});
}
exports.injectSeamless = injectSeamless;
/**
* 恢复无缝模式
*/
async function restoreSeamless() {
return request('/api/seamless/restore', 'POST');
}
exports.restoreSeamless = restoreSeamless;
/**
* 获取无缝账号列表
*/
async function getSeamlessAccounts() {
return request('/api/seamless/accounts');
}
exports.getSeamlessAccounts = getSeamlessAccounts;
/**
* 同步无缝账号
*/
async function syncSeamlessAccounts(accounts) {
return request('/api/seamless/accounts', 'POST', { accounts });
}
exports.syncSeamlessAccounts = syncSeamlessAccounts;
/**
* 获取无缝 Token
*/
async function getSeamlessToken(userKey) {
return request('/api/seamless/token?key=' + encodeURIComponent(userKey));
}
exports.getSeamlessToken = getSeamlessToken;
/**
* 切换无缝 Token
*/
async function switchSeamlessToken(userKey) {
return request('/api/seamless/switch', 'POST', {
mode: 'seamless',
userKey: userKey
});
}
exports.switchSeamlessToken = switchSeamlessToken;
/**
* 获取最新版本
*/
async function getLatestVersion() {
return request('/api/version');
}
exports.getLatestVersion = getLatestVersion;

179
deobfuscated_full/extension.js Normal file
View File

@@ -0,0 +1,179 @@
'use strict';
// ============================================
// CursorPro Extension - 反混淆版本
// ============================================
const vscode = require('vscode');
const { CursorProProvider } = require('./webview/provider');
const fs = require('fs');
const path = require('path');
let usageStatusBarItem;
// 创建输出通道
const outputChannel = vscode.window.createOutputChannel('CursorPro');
exports.outputChannel = outputChannel;
/**
* 日志输出函数
*/
function log(message) {
const timestamp = new Date().toLocaleTimeString();
outputChannel.appendLine(`[${timestamp}] ${message}`);
console.log(`[CursorPro] ${message}`);
}
exports.log = log;
/**
* 清理 Service Worker 缓存
*/
function cleanServiceWorkerCache() {
try {
const platform = process.platform;
const cachePaths = [];
if (platform === 'win32') {
const appData = process.env.APPDATA || '';
const localAppData = process.env.LOCALAPPDATA || '';
cachePaths.push(
path.join(appData, 'Cursor', 'Cache'),
path.join(localAppData, 'Cursor', 'Cache'),
path.join(appData, 'Cursor', 'GPUCache'),
path.join(localAppData, 'Cursor', 'GPUCache')
);
} else if (platform === 'darwin') {
const home = process.env.HOME || '';
cachePaths.push(
path.join(home, 'Library', 'Application Support', 'Cursor', 'Cache'),
path.join(home, 'Library', 'Application Support', 'Cursor', 'GPUCache')
);
} else {
const home = process.env.HOME || '';
cachePaths.push(
path.join(home, '.config', 'Cursor', 'Cache'),
path.join(home, '.config', 'Cursor', 'Service Worker')
);
}
for (const cachePath of cachePaths) {
if (!fs.existsSync(cachePath)) continue;
const cachesDir = path.join(cachePath, 'Caches');
if (fs.existsSync(cachesDir)) {
try {
const files = fs.readdirSync(cachesDir);
for (const file of files) {
try { fs.unlinkSync(path.join(cachesDir, file)); } catch (e) {}
}
console.log('[CursorPro] Caches 已清理:', cachesDir);
} catch (e) {}
}
const cacheStorageDir = path.join(cachePath, 'CacheStorage');
if (fs.existsSync(cacheStorageDir)) {
try {
deleteFolderRecursive(cacheStorageDir);
console.log('[CursorPro] CacheStorage 已清理:', cacheStorageDir);
} catch (e) {}
}
const databaseDir = path.join(cachePath, 'Database');
if (fs.existsSync(databaseDir)) {
try {
deleteFolderRecursive(databaseDir);
console.log('[CursorPro] Database 已清理:', databaseDir);
} catch (e) {}
}
}
} catch (error) {
console.log('[CursorPro] 清理缓存出错:', error);
}
}
function deleteFolderRecursive(folderPath) {
if (fs.existsSync(folderPath)) {
fs.readdirSync(folderPath).forEach((file) => {
const curPath = path.join(folderPath, file);
if (fs.lstatSync(curPath).isDirectory()) {
deleteFolderRecursive(curPath);
} else {
try { fs.unlinkSync(curPath); } catch (e) {}
}
});
try { fs.rmdirSync(folderPath); } catch (e) {}
}
}
/**
* 扩展激活入口
*/
function activate(context) {
cleanServiceWorkerCache();
const provider = new CursorProProvider(context.extensionUri, context);
context.subscriptions.push(
vscode.window.registerWebviewViewProvider('cursorpro.sidebar', provider)
);
usageStatusBarItem = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
usageStatusBarItem.text = '$(dashboard) CursorPro';
usageStatusBarItem.tooltip = 'CursorPro 使用情况';
usageStatusBarItem.command = 'cursorpro.showUsage';
usageStatusBarItem.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground');
const hasKey = context.globalState.get('cursorpro.key');
if (hasKey) usageStatusBarItem.show();
context.subscriptions.push(usageStatusBarItem);
context.subscriptions.setKeysForSync(['cursorpro.key']);
context.subscriptions.push(
vscode.commands.registerCommand('cursorpro.showUsage', () => {
vscode.commands.executeCommand('cursorpro.sidebar.focus');
})
);
}
exports.activate = activate;
function deactivate() {
console.log('[CursorPro] 扩展已停用');
}
exports.deactivate = deactivate;
function showStatusBar() {
if (usageStatusBarItem) usageStatusBarItem.show();
}
exports.showStatusBar = showStatusBar;
function hideStatusBar() {
if (usageStatusBarItem) usageStatusBarItem.hide();
}
exports.hideStatusBar = hideStatusBar;
function updateUsageStatusBar(requestCount, usageAmount) {
if (usageStatusBarItem) {
const count = requestCount;
const amount = typeof usageAmount === 'number'
? usageAmount
: parseFloat(usageAmount.toString().replace('$', '')) || 0;
const displayAmount = typeof usageAmount === 'number'
? '$' + usageAmount.toFixed(2)
: usageAmount;
usageStatusBarItem.text = `$(dashboard) ${count} | ${displayAmount}`;
usageStatusBarItem.tooltip = `请求次数: ${count}\n已用额度: ${displayAmount}\n点击查看详情`;
if (amount >= 10) {
usageStatusBarItem.backgroundColor = new vscode.ThemeColor('statusBarItem.errorBackground');
usageStatusBarItem.color = undefined;
} else if (amount >= 5) {
usageStatusBarItem.backgroundColor = new vscode.ThemeColor('statusBarItem.warningBackground');
usageStatusBarItem.color = undefined;
} else {
usageStatusBarItem.backgroundColor = undefined;
usageStatusBarItem.color = 'statusBarItem.warningBackground';
}
}
}
exports.updateUsageStatusBar = updateUsageStatusBar;

1
deobfuscated_full/out/api/client.js Normal file
View File

File diff suppressed because one or more lines are too long

1
deobfuscated_full/out/extension.js Normal file
View File

File diff suppressed because one or more lines are too long

1
deobfuscated_full/out/utils/account.js Normal file
View File

File diff suppressed because one or more lines are too long

1
deobfuscated_full/out/utils/sqlite.js Normal file
View File

File diff suppressed because one or more lines are too long

1
deobfuscated_full/out/webview/provider.js Normal file
View File

File diff suppressed because one or more lines are too long

263
deobfuscated_full/seamless.js Normal file
View File

@@ -0,0 +1,263 @@
'use strict';
// ============================================
// CursorPro 无感换号模块 - 详细分析
// ============================================
const vscode = require('vscode');
const client = require('./api/client');
const account = require('./utils/account');
/**
* ============================================
* 无感换号 (Seamless Mode) 工作原理
* ============================================
*
* 核心思路：
* 1. 用户配置一个"账号池"，包含多个 Cursor 账号的 token
* 2. 当检测到当前账号额度用尽或即将用尽时
* 3. 自动从账号池中选择下一个可用账号
* 4. 无缝切换到新账号，用户无感知
*
* 关键 API 端点：
* - /api/seamless/status 获取无缝模式状态
* - /api/seamless/config 获取/更新无缝配置
* - /api/seamless/inject 注入无缝模式到本地
* - /api/seamless/restore 恢复原始设置
* - /api/seamless/accounts 获取账号池列表
* - /api/seamless/token 获取指定账号的 token
* - /api/seamless/switch 切换到指定账号
*/
// ============================================
// 无缝模式配置结构
// ============================================
/**
* @typedef {Object} SeamlessConfig
* @property {boolean} enabled - 是否启用无缝模式
* @property {string} mode - 切换模式: 'auto' | 'manual'
* @property {number} switchThreshold - 切换阈值 (剩余额度百分比)
* @property {string[]} accountPool - 账号池 (userKey 列表)
* @property {number} currentIndex - 当前使用的账号索引
*/
const defaultSeamlessConfig = {
enabled: false,
mode: 'auto', // 自动切换
switchThreshold: 10, // 当剩余额度低于 10% 时切换
accountPool: [],
currentIndex: 0
};
// ============================================
// 无缝模式核心函数
// ============================================
/**
* 获取无缝模式状态
* 检查服务端是否支持无缝模式，以及当前用户是否有权使用
*/
async function getSeamlessStatus() {
return client.request('/api/seamless/status');
}
/**
* 获取无缝模式配置
* 从服务端获取用户的无缝模式配置
*/
async function getSeamlessConfig() {
return client.request('/api/seamless/config');
}
/**
* 更新无缝模式配置
* @param {SeamlessConfig} config - 新的配置
*/
async function updateSeamlessConfig(config) {
return client.request('/api/seamless/config', 'POST', config);
}
/**
* 获取用户切换状态
* 检查指定用户当前的使用状态，判断是否需要切换
* @param {string} userKey - 用户标识
*/
async function getUserSwitchStatus(userKey) {
return client.request('/api/seamless/user-status?key=' + encodeURIComponent(userKey));
}
/**
* 注入无缝模式
* 将无缝模式的配置写入本地 Cursor
*
* 这是无感换号的核心！
* 它会修改 Cursor 的认证配置，使其指向一个代理服务器
* 代理服务器会自动处理账号切换
*
* @param {string} apiUrl - 无缝模式的 API 代理地址
* @param {string} userKey - 用户标识
*/
async function injectSeamless(apiUrl, userKey) {
const result = await client.request('/api/seamless/inject', 'POST', {
api_url: apiUrl,
user_key: userKey
});
if (result.success && result.data) {
// 将返回的账号数据写入本地
// 这里的关键是：写入的 token 是代理服务器的 token
// 代理服务器会根据使用情况自动切换真实账号
await account.writeAccountToLocal(result.data);
}
return result;
}
/**
* 恢复原始设置
* 移除无缝模式，恢复到单账号模式
*/
async function restoreSeamless() {
return client.request('/api/seamless/restore', 'POST');
}
/**
* 获取账号池列表
* 返回用户配置的所有账号
*/
async function getSeamlessAccounts() {
return client.request('/api/seamless/accounts');
}
/**
* 同步账号池
* 将本地账号列表同步到服务端
* @param {Array} accounts - 账号列表
*/
async function syncSeamlessAccounts(accounts) {
return client.request('/api/seamless/accounts', 'POST', { accounts });
}
/**
* 获取指定账号的 Token
* @param {string} userKey - 用户标识
*/
async function getSeamlessToken(userKey) {
return client.request('/api/seamless/token?key=' + encodeURIComponent(userKey));
}
/**
* 手动切换到指定账号
* @param {string} userKey - 要切换到的账号标识
*/
async function switchSeamlessToken(userKey) {
const result = await client.request('/api/seamless/switch', 'POST', {
mode: 'seamless',
userKey: userKey
});
if (result.success && result.data) {
await account.writeAccountToLocal(result.data);
}
return result;
}
// ============================================
// 无感换号流程图
// ============================================
/**
*
* ┌─────────────────────────────────────────────────────────────────┐
* │ 无感换号工作流程 │
* ├─────────────────────────────────────────────────────────────────┤
* │ │
* │ ┌──────────────┐ │
* │ │ 用户请求 │ │
* │ │ (使用 Cursor) │ │
* │ └──────┬───────┘ │
* │ │ │
* │ ▼ │
* │ ┌──────────────┐ ┌──────────────┐ │
* │ │ Cursor 客户端 │────▶│ 代理服务器 │ (CursorPro API) │
* │ │ (本地修改后) │ │ │ │
* │ └──────────────┘ └──────┬───────┘ │
* │ │ │
* │ ▼ │
* │ ┌──────────────┐ │
* │ │ 检查当前账号 │ │
* │ │ 额度是否充足 │ │
* │ └──────┬───────┘ │
* │ │ │
* │ ┌───────────────┼───────────────┐ │
* │ │ │ │ │
* │ ▼ ▼ ▼ │
* │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
* │ │ 账号 A │ │ 账号 B │ │ 账号 C │ (账号池) │
* │ │ 额度:5% │ │ 额度:80% │ │ 额度:60% │ │
* │ └─────────┘ └────┬────┘ └─────────┘ │
* │ │ │
* │ ▼ │
* │ ┌──────────────┐ │
* │ │ 使用账号 B │ (额度最充足) │
* │ │ 转发请求 │ │
* │ └──────┬───────┘ │
* │ │ │
* │ ▼ │
* │ ┌──────────────┐ │
* │ │ Cursor API │ │
* │ │ (官方服务器) │ │
* │ └──────┬───────┘ │
* │ │ │
* │ ▼ │
* │ ┌──────────────┐ │
* │ │ 返回结果给 │ │
* │ │ 用户 │ │
* │ └──────────────┘ │
* │ │
* │ 用户全程无感知，只要账号池中有任一账号有额度，就能继续使用 │
* │ │
* └─────────────────────────────────────────────────────────────────┘
*
*/
// ============================================
// 无感换号的技术实现细节
// ============================================
/**
* 关键技术点：
*
* 1. 代理注入
* - 修改本地 Cursor 的 API 端点指向代理服务器
* - 所有请求先经过代理，代理决定使用哪个真实账号
*
* 2. Token 管理
* - 代理服务器维护账号池的所有 token
* - 根据各账号的额度情况动态选择
*
* 3. 切换策略
* - 自动模式：当前账号额度 < 阈值时自动切换
* - 手动模式：用户手动选择要使用的账号
*
* 4. 本地写入的数据
* - accessToken: 代理服务器生成的特殊 token
* - refreshToken: 用于刷新代理 token
* - 设备 ID: 统一使用代理分配的 ID，避免被检测
*/
const seamlessModule = {
getSeamlessStatus,
getSeamlessConfig,
updateSeamlessConfig,
getUserSwitchStatus,
injectSeamless,
restoreSeamless,
getSeamlessAccounts,
syncSeamlessAccounts,
getSeamlessToken,
switchSeamlessToken
};
module.exports = seamlessModule;

226
deobfuscated_full/utils/account.js Normal file
View File

@@ -0,0 +1,226 @@
'use strict';
// ============================================
// CursorPro Account Utils - 反混淆版本
// ============================================
const vscode = require('vscode');
const path = require('path');
const fs = require('fs');
const { exec } = require('child_process');
const { promisify } = require('util');
const { sqliteSetBatch } = require('./sqlite');
const execAsync = promisify(exec);
/**
* 获取 Cursor 相关路径
* 返回数据库路径、存储路径和机器ID路径
*/
function getCursorPaths() {
const home = process.env.HOME || process.env.USERPROFILE || '';
if (process.platform === 'win32') {
// Windows 路径
const appData = process.env.APPDATA || '';
return {
dbPath: path.join(appData, 'Cursor', 'User', 'globalStorage', 'state.vscdb'),
storagePath: path.join(appData, 'Cursor', 'User', 'globalStorage', 'storage.json'),
machineidPath: path.join(appData, 'Cursor', 'machineid')
};
} else if (process.platform === 'darwin') {
// macOS 路径
return {
dbPath: path.join(home, 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb'),
storagePath: path.join(home, 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'storage.json'),
machineidPath: path.join(home, 'Library', 'Application Support', 'Cursor', 'machineid')
};
} else {
// Linux 路径
return {
dbPath: path.join(home, '.config', 'Cursor', 'User', 'globalStorage', 'state.vscdb'),
storagePath: path.join(home, '.config', 'Cursor', 'User', 'globalStorage', 'storage.json'),
machineidPath: path.join(home, '.config', 'Cursor', 'machineid')
};
}
}
exports.getCursorPaths = getCursorPaths;
/**
* 将账号数据写入本地
* @param {Object} accountData - 账号数据对象
* @param {string} accountData.accessToken - 访问令牌
* @param {string} accountData.refreshToken - 刷新令牌
* @param {string} accountData.workosSessionToken - WorkOS 会话令牌
* @param {string} accountData.email - 邮箱
* @param {string} accountData.membership_type - 会员类型
* @param {string} accountData.usage_type - 使用类型
* @param {string} accountData.serviceMachineId - 服务机器ID
* @param {string} accountData.machineId - 机器ID
* @param {string} accountData.macMachineId - Mac机器ID
* @param {string} accountData.devDeviceId - 设备ID
* @param {string} accountData.sqmId - SQM ID
* @param {string} accountData.machineIdFile - 机器ID文件内容
*/
async function writeAccountToLocal(accountData) {
try {
const paths = getCursorPaths();
const { dbPath, storagePath, machineidPath } = paths;
console.log('[CursorPro] 数据库路径:', dbPath);
console.log('[CursorPro] 文件是否存在:', fs.existsSync(dbPath));
console.log('[CursorPro] 账号数据:', JSON.stringify({
hasAccessToken: !!accountData.accessToken,
hasRefreshToken: !!accountData.refreshToken,
hasWorkosToken: !!accountData.workosSessionToken,
email: accountData.email
}));
// 写入数据库
if (fs.existsSync(dbPath)) {
try {
const kvPairs = [];
// 添加访问令牌
if (accountData.accessToken) {
kvPairs.push(['cursorAuth/accessToken', accountData.accessToken]);
}
// 添加刷新令牌
if (accountData.refreshToken) {
kvPairs.push(['cursorAuth/refreshToken', accountData.refreshToken]);
}
// 添加 WorkOS 会话令牌
if (accountData.workosSessionToken) {
kvPairs.push(['cursorAuth/WorkosCursorSessionToken', accountData.workosSessionToken]);
}
// 添加邮箱
if (accountData.email) {
kvPairs.push(['cursorAuth/cachedEmail', accountData.email]);
}
// 添加会员类型
if (accountData.membership_type) {
kvPairs.push(['cursorAuth/stripeMembershipType', accountData.membership_type]);
}
// 添加使用类型
if (accountData.usage_type) {
kvPairs.push(['cursorAuth/stripeUsageType', accountData.usage_type || 'default']);
}
// 添加服务机器ID
if (accountData.serviceMachineId) {
kvPairs.push(['telemetry.serviceMachineId', accountData.serviceMachineId]);
}
console.log('[CursorPro] 待写入数据库:', kvPairs.length);
// 批量写入数据库
const result = await sqliteSetBatch(dbPath, kvPairs);
if (!result) {
throw new Error('数据库写入失败');
}
console.log('[CursorPro] 数据库已更新:', kvPairs.length, '个字段');
} catch (error) {
console.error('[CursorPro] 数据库操作失败:', error);
vscode.window.showErrorMessage('数据库写入失败: ' + error);
return false;
}
} else {
console.error('[CursorPro] 数据库文件不存在:', dbPath);
vscode.window.showErrorMessage('[CursorPro] 数据库文件不存在');
return false;
}
// 更新 storage.json
if (fs.existsSync(storagePath)) {
const storageData = JSON.parse(fs.readFileSync(storagePath, 'utf-8'));
if (accountData.machineId) {
storageData['telemetry.machineId'] = accountData.machineId;
}
if (accountData.macMachineId) {
storageData['telemetry.macMachineId'] = accountData.macMachineId;
}
if (accountData.devDeviceId) {
storageData['telemetry.devDeviceId'] = accountData.devDeviceId;
}
if (accountData.sqmId) {
storageData['telemetry.sqmId'] = accountData.sqmId;
}
fs.writeFileSync(storagePath, JSON.stringify(storageData, null, 4));
console.log('[CursorPro] storage.json 已更新');
}
// 更新 machineid 文件
if (accountData.machineIdFile && machineidPath) {
const dir = path.dirname(machineidPath);
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir, { recursive: true });
}
fs.writeFileSync(machineidPath, accountData.machineIdFile);
console.log('[CursorPro] machineid 文件已更新');
}
// Windows 注册表写入 (如果有 sqmId)
if (accountData.sqmId && process.platform === 'win32') {
try {
const regCommand = `reg add "HKCU\\Software\\Cursor" /v SQMId /t REG_SZ /d "${accountData.sqmId}" /f`;
await execAsync(regCommand);
console.log('[CursorPro] 注册表已更新');
} catch (error) {
console.warn('[CursorPro] 注册表写入失败（可能需要管理员权限）:', error);
}
}
return true;
} catch (error) {
console.error('[CursorPro] writeAccountToLocal 失败:', error);
return false;
}
}
exports.writeAccountToLocal = writeAccountToLocal;
/**
* 关闭 Cursor 进程
*/
async function closeCursor() {
try {
if (process.platform === 'win32') {
// Windows: 使用 taskkill
await execAsync('taskkill /F /IM Cursor.exe').catch(() => {});
} else {
// macOS/Linux: 使用 pkill
await execAsync('pkill -9 -f Cursor').catch(() => {});
}
} catch (error) {
console.warn('[CursorPro] 关闭 Cursor 失败:', error);
}
}
exports.closeCursor = closeCursor;
/**
* 提示用户重启 Cursor
*/
async function promptRestartCursor(message) {
const selection = await vscode.window.showInformationMessage(
message,
'立即重启',
'稍后手动重启'
);
if (selection === '立即重启') {
await closeCursor();
}
}
exports.promptRestartCursor = promptRestartCursor;

203
deobfuscated_full/utils/sqlite.js Normal file
View File

@@ -0,0 +1,203 @@
'use strict';
// ============================================
// CursorPro SQLite Utils - 反混淆版本
// ============================================
const { exec } = require('child_process');
const { promisify } = require('util');
const fs = require('fs');
const execAsync = promisify(exec);
/**
* 转义 SQL 字符串中的单引号
*/
function escapeSqlString(value) {
if (value === null || value === undefined) {
return '';
}
return String(value).replace(/'/g, "''");
}
/**
* 执行 SQLite 命令
* @param {string} dbPath - 数据库文件路径
* @param {string} sql - SQL 语句
* @returns {Promise<string>} - 执行结果
*/
async function execSqlite(dbPath, sql) {
const isWindows = process.platform === 'win32';
try {
if (isWindows) {
// Windows: 直接使用 sqlite3 命令
const escapedSql = sql.replace(/"/g, '\\"');
const command = `sqlite3 "${dbPath}" "${escapedSql}"`;
const { stdout, stderr } = await execAsync(command, {
encoding: 'utf-8',
maxBuffer: 10 * 1024 * 1024 // 10MB
});
if (stderr && !stderr.includes('-- Loading')) {
console.warn('[SQLite] stderr:', stderr);
}
return stdout.trim();
} else {
// macOS/Linux: 使用临时文件避免转义问题
const os = require('os');
const pathModule = require('path');
const tempFile = pathModule.join(
os.tmpdir(),
'cursor_sql_' + Date.now() + '.sql'
);
// 写入 SQL 到临时文件
fs.writeFileSync(tempFile, sql, 'utf-8');
try {
const command = `sqlite3 "${dbPath}" < "${tempFile}"`;
const { stdout, stderr } = await execAsync(command, {
encoding: 'utf-8',
maxBuffer: 10 * 1024 * 1024,
shell: '/bin/bash'
});
if (stderr && !stderr.includes('-- Loading')) {
console.warn('[SQLite] stderr:', stderr);
}
return stdout.trim();
} finally {
// 清理临时文件
try {
fs.unlinkSync(tempFile);
} catch (e) {}
}
}
} catch (error) {
// 检查是否是 sqlite3 不存在的错误
if (
error.message === 'ENOENT' ||
error.message?.includes('sqlite3') ||
error.message?.includes('not found')
) {
throw new Error('sqlite3 命令不存在，请先安装 SQLite3');
}
throw error;
}
}
/**
* 从 SQLite 数据库读取单个值
* @param {string} dbPath - 数据库路径
* @param {string} key - 键名
* @returns {Promise<string|null>} - 值或 null
*/
async function sqliteGet(dbPath, key) {
if (!fs.existsSync(dbPath)) {
console.warn('[SQLite] 数据库文件不存在:', dbPath);
return null;
}
try {
const sql = `SELECT value FROM ItemTable WHERE key = '${escapeSqlString(key)}';`;
const result = await execSqlite(dbPath, sql);
return result || null;
} catch (error) {
console.error('[SQLite] 读取失败:', error);
return null;
}
}
exports.sqliteGet = sqliteGet;
/**
* 向 SQLite 数据库写入单个值
* @param {string} dbPath - 数据库路径
* @param {string} key - 键名
* @param {string} value - 值
* @returns {Promise<boolean>} - 是否成功
*/
async function sqliteSet(dbPath, key, value) {
if (!fs.existsSync(dbPath)) {
console.warn('[SQLite] 数据库文件不存在:', dbPath);
return false;
}
try {
// 使用 REPLACE INTO 实现 upsert
const sql = `REPLACE INTO ItemTable (key, value) VALUES ('${escapeSqlString(key)}', '${escapeSqlString(value)}');`;
await execSqlite(dbPath, sql);
return true;
} catch (error) {
console.error('[SQLite] 写入失败:', error);
return false;
}
}
exports.sqliteSet = sqliteSet;
/**
* 批量写入 SQLite 数据库
* @param {string} dbPath - 数据库路径
* @param {Array<[string, string]>} kvPairs - 键值对数组
* @returns {Promise<boolean>} - 是否成功
*/
async function sqliteSetBatch(dbPath, kvPairs) {
if (!fs.existsSync(dbPath)) {
console.warn('[SQLite] 数据库文件不存在:', dbPath);
return false;
}
if (kvPairs.length === 0) {
return true;
}
try {
// 构建批量 SQL 语句
const statements = kvPairs.map(([key, value]) =>
`REPLACE INTO ItemTable (key, value) VALUES ('${escapeSqlString(key)}', '${escapeSqlString(value)}');`
);
const sql = 'BEGIN TRANSACTION; ' + statements.join(' ') + ' COMMIT;';
await execSqlite(dbPath, sql);
return true;
} catch (error) {
console.error('[SQLite] 批量写入失败:', error);
return false;
}
}
exports.sqliteSetBatch = sqliteSetBatch;
/**
* 批量读取 SQLite 数据库
* @param {string} dbPath - 数据库路径
* @param {string[]} keys - 键名数组
* @returns {Promise<Map<string, string|null>>} - 键值 Map
*/
async function sqliteGetBatch(dbPath, keys) {
const resultMap = new Map();
if (!fs.existsSync(dbPath)) {
console.warn('[SQLite] 数据库文件不存在:', dbPath);
keys.forEach(key => resultMap.set(key, null));
return resultMap;
}
try {
// 逐个读取 (SQLite CLI 批量读取输出解析较复杂)
for (const key of keys) {
const value = await sqliteGet(dbPath, key);
resultMap.set(key, value);
}
return resultMap;
} catch (error) {
console.error('[SQLite] 批量读取失败:', error);
keys.forEach(key => resultMap.set(key, null));
return resultMap;
}
}
exports.sqliteGetBatch = sqliteGetBatch;

956
deobfuscated_full/webview/provider.js Normal file
View File

@@ -0,0 +1,956 @@
'use strict';
// ============================================
// CursorPro Webview Provider - 反混淆版本
// ============================================
const vscode = require('vscode');
const client = require('../api/client');
const account = require('../utils/account');
const extension = require('../extension');
/**
* CursorPro Webview Provider
* 处理侧边栏 webview 的显示和交互
*/
class CursorProProvider {
constructor(extensionUri, context) {
this._extensionUri = extensionUri;
this._context = context;
this._view = undefined;
}
/**
* 解析 webview 视图
*/
resolveWebviewView(webviewView, context, token) {
this._view = webviewView;
webviewView.webview.options = {
enableScripts: true,
localResourceRoots: [this._extensionUri]
};
// 设置 HTML 内容
webviewView.webview.html = this._getHtmlContent(webviewView.webview);
// 处理来自 webview 的消息
webviewView.webview.onDidReceiveMessage(async (message) => {
await this._handleMessage(message);
});
// 监听在线状态变化
client.onOnlineStatusChange((isOnline) => {
this._postMessage({
type: 'onlineStatus',
isOnline: isOnline
});
});
}
/**
* 发送消息到 webview
*/
_postMessage(message) {
if (this._view) {
this._view.webview.postMessage(message);
}
}
/**
* 处理来自 webview 的消息
*/
async _handleMessage(message) {
const { type, data } = message;
try {
switch (type) {
case 'verifyKey':
await this._handleVerifyKey(data);
break;
case 'switchAccount':
await this._handleSwitchAccount(data);
break;
case 'getSeamlessStatus':
await this._handleGetSeamlessStatus();
break;
case 'getSeamlessConfig':
await this._handleGetSeamlessConfig();
break;
case 'updateSeamlessConfig':
await this._handleUpdateSeamlessConfig(data);
break;
case 'injectSeamless':
await this._handleInjectSeamless(data);
break;
case 'restoreSeamless':
await this._handleRestoreSeamless();
break;
case 'getSeamlessAccounts':
await this._handleGetSeamlessAccounts();
break;
case 'syncSeamlessAccounts':
await this._handleSyncSeamlessAccounts(data);
break;
case 'switchSeamlessToken':
await this._handleSwitchSeamlessToken(data);
break;
case 'getProxyConfig':
await this._handleGetProxyConfig();
break;
case 'updateProxyConfig':
await this._handleUpdateProxyConfig(data);
break;
case 'checkVersion':
await this._handleCheckVersion();
break;
case 'openExternal':
vscode.env.openExternal(vscode.Uri.parse(data.url));
break;
case 'showMessage':
this._showMessage(data.messageType, data.message);
break;
case 'getStoredKey':
await this._handleGetStoredKey();
break;
case 'logout':
await this._handleLogout();
break;
default:
console.warn('[CursorPro] 未知消息类型:', type);
}
} catch (error) {
console.error('[CursorPro] 处理消息失败:', error);
this._postMessage({
type: 'error',
error: error.message || '操作失败'
});
}
}
/**
* 验证 Key
*/
async _handleVerifyKey(data) {
const { key } = data;
extension.log('开始验证 Key...');
const result = await client.verifyKey(key);
if (result.success) {
// 保存 key 到全局状态
await this._context.globalState.update('cursorpro.key', key);
// 写入账号数据到本地
if (result.data) {
const writeResult = await account.writeAccountToLocal(result.data);
if (writeResult) {
extension.showStatusBar();
extension.updateUsageStatusBar(
result.data.requestCount || 0,
result.data.usageAmount || 0
);
// 提示重启
await account.promptRestartCursor('账号切换成功，需要重启 Cursor 生效');
}
}
}
this._postMessage({
type: 'verifyKeyResult',
result: result
});
}
/**
* 切换账号
*/
async _handleSwitchAccount(data) {
const { key } = data;
extension.log('开始切换账号...');
const result = await client.switchAccount(key);
if (result.success && result.data) {
const writeResult = await account.writeAccountToLocal(result.data);
if (writeResult) {
extension.updateUsageStatusBar(
result.data.requestCount || 0,
result.data.usageAmount || 0
);
await account.promptRestartCursor('账号切换成功，需要重启 Cursor 生效');
}
}
this._postMessage({
type: 'switchAccountResult',
result: result
});
}
/**
* 获取无缝模式状态
*/
async _handleGetSeamlessStatus() {
const result = await client.getSeamlessStatus();
this._postMessage({
type: 'seamlessStatusResult',
result: result
});
}
/**
* 获取无缝配置
*/
async _handleGetSeamlessConfig() {
const result = await client.getSeamlessConfig();
this._postMessage({
type: 'seamlessConfigResult',
result: result
});
}
/**
* 更新无缝配置
*/
async _handleUpdateSeamlessConfig(data) {
const result = await client.updateSeamlessConfig(data);
this._postMessage({
type: 'updateSeamlessConfigResult',
result: result
});
}
/**
* 注入无缝模式
*/
async _handleInjectSeamless(data) {
const { apiUrl, userKey } = data;
const result = await client.injectSeamless(apiUrl, userKey);
if (result.success && result.data) {
const writeResult = await account.writeAccountToLocal(result.data);
if (writeResult) {
await account.promptRestartCursor('无缝模式注入成功，需要重启 Cursor 生效');
}
}
this._postMessage({
type: 'injectSeamlessResult',
result: result
});
}
/**
* 恢复无缝模式
*/
async _handleRestoreSeamless() {
const result = await client.restoreSeamless();
if (result.success) {
await account.promptRestartCursor('已恢复默认设置，需要重启 Cursor 生效');
}
this._postMessage({
type: 'restoreSeamlessResult',
result: result
});
}
/**
* 获取无缝账号列表
*/
async _handleGetSeamlessAccounts() {
const result = await client.getSeamlessAccounts();
this._postMessage({
type: 'seamlessAccountsResult',
result: result
});
}
/**
* 同步无缝账号
*/
async _handleSyncSeamlessAccounts(data) {
const result = await client.syncSeamlessAccounts(data.accounts);
this._postMessage({
type: 'syncSeamlessAccountsResult',
result: result
});
}
/**
* 切换无缝 Token
*/
async _handleSwitchSeamlessToken(data) {
const { userKey } = data;
const result = await client.switchSeamlessToken(userKey);
if (result.success && result.data) {
const writeResult = await account.writeAccountToLocal(result.data);
if (writeResult) {
extension.updateUsageStatusBar(
result.data.requestCount || 0,
result.data.usageAmount || 0
);
await account.promptRestartCursor('Token 切换成功，需要重启 Cursor 生效');
}
}
this._postMessage({
type: 'switchSeamlessTokenResult',
result: result
});
}
/**
* 获取代理配置
*/
async _handleGetProxyConfig() {
const result = await client.getProxyConfig();
this._postMessage({
type: 'proxyConfigResult',
result: result
});
}
/**
* 更新代理配置
*/
async _handleUpdateProxyConfig(data) {
const { isEnabled, proxyUrl } = data;
const result = await client.updateProxyConfig(isEnabled, proxyUrl);
this._postMessage({
type: 'updateProxyConfigResult',
result: result
});
}
/**
* 检查版本
*/
async _handleCheckVersion() {
const result = await client.getLatestVersion();
this._postMessage({
type: 'versionResult',
result: result
});
}
/**
* 获取存储的 Key
*/
async _handleGetStoredKey() {
const key = this._context.globalState.get('cursorpro.key');
this._postMessage({
type: 'storedKeyResult',
key: key || null
});
}
/**
* 登出
*/
async _handleLogout() {
await this._context.globalState.update('cursorpro.key', undefined);
extension.hideStatusBar();
this._postMessage({
type: 'logoutResult',
success: true
});
}
/**
* 显示消息
*/
_showMessage(messageType, message) {
switch (messageType) {
case 'info':
vscode.window.showInformationMessage(message);
break;
case 'warning':
vscode.window.showWarningMessage(message);
break;
case 'error':
vscode.window.showErrorMessage(message);
break;
default:
vscode.window.showInformationMessage(message);
}
}
/**
* 生成 Webview HTML 内容
*/
_getHtmlContent(webview) {
const styleUri = webview.asWebviewUri(
vscode.Uri.joinPath(this._extensionUri, 'media', 'style.css')
);
const scriptUri = webview.asWebviewUri(
vscode.Uri.joinPath(this._extensionUri, 'media', 'main.js')
);
const nonce = this._getNonce();
return `<!DOCTYPE html>
<html lang="zh-CN">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src ${webview.cspSource} 'unsafe-inline'; script-src 'nonce-${nonce}';">
<title>CursorPro</title>
<style>
:root {
--container-padding: 16px;
--input-padding: 8px 12px;
--border-radius: 6px;
}
body {
padding: var(--container-padding);
font-family: var(--vscode-font-family);
font-size: var(--vscode-font-size);
color: var(--vscode-foreground);
}
.section {
margin-bottom: 20px;
}
.section-title {
font-size: 14px;
font-weight: 600;
margin-bottom: 12px;
color: var(--vscode-foreground);
}
input[type="text"],
input[type="password"] {
width: 100%;
padding: var(--input-padding);
border: 1px solid var(--vscode-input-border);
background: var(--vscode-input-background);
color: var(--vscode-input-foreground);
border-radius: var(--border-radius);
box-sizing: border-box;
margin-bottom: 8px;
}
input:focus {
outline: 1px solid var(--vscode-focusBorder);
}
button {
width: 100%;
padding: 10px 16px;
border: none;
border-radius: var(--border-radius);
background: var(--vscode-button-background);
color: var(--vscode-button-foreground);
cursor: pointer;
font-size: 13px;
font-weight: 500;
margin-bottom: 8px;
}
button:hover {
background: var(--vscode-button-hoverBackground);
}
button:disabled {
opacity: 0.5;
cursor: not-allowed;
}
button.secondary {
background: var(--vscode-button-secondaryBackground);
color: var(--vscode-button-secondaryForeground);
}
button.secondary:hover {
background: var(--vscode-button-secondaryHoverBackground);
}
.status {
padding: 12px;
border-radius: var(--border-radius);
margin-bottom: 12px;
font-size: 12px;
}
.status.online {
background: rgba(40, 167, 69, 0.1);
border: 1px solid rgba(40, 167, 69, 0.3);
color: #28a745;
}
.status.offline {
background: rgba(220, 53, 69, 0.1);
border: 1px solid rgba(220, 53, 69, 0.3);
color: #dc3545;
}
.info-box {
padding: 12px;
background: var(--vscode-textBlockQuote-background);
border-left: 3px solid var(--vscode-textLink-foreground);
border-radius: 0 var(--border-radius) var(--border-radius) 0;
margin-bottom: 12px;
font-size: 12px;
}
.usage-stats {
display: flex;
justify-content: space-between;
padding: 12px;
background: var(--vscode-editor-background);
border: 1px solid var(--vscode-panel-border);
border-radius: var(--border-radius);
margin-bottom: 12px;
}
.usage-stat {
text-align: center;
}
.usage-stat-value {
font-size: 20px;
font-weight: 600;
color: var(--vscode-textLink-foreground);
}
.usage-stat-label {
font-size: 11px;
color: var(--vscode-descriptionForeground);
margin-top: 4px;
}
.account-card {
padding: 12px;
background: var(--vscode-editor-background);
border: 1px solid var(--vscode-panel-border);
border-radius: var(--border-radius);
margin-bottom: 8px;
}
.account-email {
font-weight: 500;
margin-bottom: 4px;
}
.account-type {
font-size: 11px;
color: var(--vscode-descriptionForeground);
}
.hidden {
display: none;
}
.loading {
display: flex;
align-items: center;
justify-content: center;
padding: 20px;
}
.spinner {
width: 20px;
height: 20px;
border: 2px solid var(--vscode-foreground);
border-top-color: transparent;
border-radius: 50%;
animation: spin 1s linear infinite;
}
@keyframes spin {
to { transform: rotate(360deg); }
}
.tabs {
display: flex;
border-bottom: 1px solid var(--vscode-panel-border);
margin-bottom: 16px;
}
.tab {
padding: 8px 16px;
cursor: pointer;
border-bottom: 2px solid transparent;
color: var(--vscode-descriptionForeground);
}
.tab:hover {
color: var(--vscode-foreground);
}
.tab.active {
color: var(--vscode-textLink-foreground);
border-bottom-color: var(--vscode-textLink-foreground);
}
.tab-content {
display: none;
}
.tab-content.active {
display: block;
}
.toggle {
display: flex;
align-items: center;
justify-content: space-between;
padding: 8px 0;
}
.toggle-switch {
position: relative;
width: 40px;
height: 20px;
background: var(--vscode-input-background);
border-radius: 10px;
cursor: pointer;
transition: background 0.2s;
}
.toggle-switch.active {
background: var(--vscode-textLink-foreground);
}
.toggle-switch::after {
content: '';
position: absolute;
top: 2px;
left: 2px;
width: 16px;
height: 16px;
background: white;
border-radius: 50%;
transition: transform 0.2s;
}
.toggle-switch.active::after {
transform: translateX(20px);
}
</style>
</head>
<body>
<div id="app">
<!-- 连接状态 -->
<div id="connection-status" class="status online">
<span id="status-icon">●</span>
<span id="status-text">已连接</span>
</div>
<!-- 标签页 -->
<div class="tabs">
<div class="tab active" data-tab="main">主页</div>
<div class="tab" data-tab="seamless">无缝模式</div>
<div class="tab" data-tab="settings">设置</div>
</div>
<!-- 主页内容 -->
<div id="tab-main" class="tab-content active">
<!-- 登录区域 -->
<div id="login-section" class="section">
<div class="section-title">激活 CursorPro</div>
<input type="password" id="key-input" placeholder="请输入您的激活码">
<button id="verify-btn">验证激活码</button>
</div>
<!-- 已登录区域 -->
<div id="logged-in-section" class="section hidden">
<div class="section-title">使用统计</div>
<div class="usage-stats">
<div class="usage-stat">
<div class="usage-stat-value" id="request-count">0</div>
<div class="usage-stat-label">请求次数</div>
</div>
<div class="usage-stat">
<div class="usage-stat-value" id="usage-amount">$0.00</div>
<div class="usage-stat-label">已用额度</div>
</div>
</div>
<div class="account-card">
<div class="account-email" id="account-email">-</div>
<div class="account-type" id="account-type">-</div>
</div>
<button id="switch-btn" class="secondary">切换账号</button>
<button id="logout-btn" class="secondary">退出登录</button>
</div>
</div>
<!-- 无缝模式内容 -->
<div id="tab-seamless" class="tab-content">
<div class="section">
<div class="section-title">无缝模式</div>
<div class="info-box">
无缝模式允许您在多个账号之间自动切换，实现不间断使用。
</div>
<div class="toggle">
<span>启用无缝模式</span>
<div id="seamless-toggle" class="toggle-switch"></div>
</div>
<div id="seamless-accounts" class="hidden">
<div class="section-title" style="margin-top: 16px;">账号池</div>
<div id="accounts-list"></div>
<button id="sync-accounts-btn" class="secondary">同步账号</button>
</div>
</div>
</div>
<!-- 设置内容 -->
<div id="tab-settings" class="tab-content">
<div class="section">
<div class="section-title">代理设置</div>
<div class="toggle">
<span>启用代理</span>
<div id="proxy-toggle" class="toggle-switch"></div>
</div>
<input type="text" id="proxy-url" placeholder="代理地址 (如: http://127.0.0.1:7890)" class="hidden">
<button id="save-proxy-btn" class="secondary hidden">保存代理设置</button>
</div>
<div class="section">
<div class="section-title">关于</div>
<div class="info-box">
<strong>CursorPro</strong><br>
版本: <span id="version">0.4.5</span><br>
<a href="#" id="check-update-link">检查更新</a>
</div>
</div>
</div>
</div>
<script nonce="${nonce}">
(function() {
const vscode = acquireVsCodeApi();
// 元素引用
const elements = {
connectionStatus: document.getElementById('connection-status'),
statusText: document.getElementById('status-text'),
keyInput: document.getElementById('key-input'),
verifyBtn: document.getElementById('verify-btn'),
loginSection: document.getElementById('login-section'),
loggedInSection: document.getElementById('logged-in-section'),
requestCount: document.getElementById('request-count'),
usageAmount: document.getElementById('usage-amount'),
accountEmail: document.getElementById('account-email'),
accountType: document.getElementById('account-type'),
switchBtn: document.getElementById('switch-btn'),
logoutBtn: document.getElementById('logout-btn'),
seamlessToggle: document.getElementById('seamless-toggle'),
seamlessAccounts: document.getElementById('seamless-accounts'),
accountsList: document.getElementById('accounts-list'),
proxyToggle: document.getElementById('proxy-toggle'),
proxyUrl: document.getElementById('proxy-url'),
saveProxyBtn: document.getElementById('save-proxy-btn')
};
// 标签页切换
document.querySelectorAll('.tab').forEach(tab => {
tab.addEventListener('click', () => {
document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
document.querySelectorAll('.tab-content').forEach(c => c.classList.remove('active'));
tab.classList.add('active');
document.getElementById('tab-' + tab.dataset.tab).classList.add('active');
});
});
// 验证按钮点击
elements.verifyBtn.addEventListener('click', () => {
const key = elements.keyInput.value.trim();
if (!key) {
vscode.postMessage({ type: 'showMessage', data: { messageType: 'warning', message: '请输入激活码' }});
return;
}
elements.verifyBtn.disabled = true;
elements.verifyBtn.textContent = '验证中...';
vscode.postMessage({ type: 'verifyKey', data: { key } });
});
// 切换账号按钮
elements.switchBtn.addEventListener('click', () => {
vscode.postMessage({ type: 'getStoredKey' });
});
// 退出登录按钮
elements.logoutBtn.addEventListener('click', () => {
vscode.postMessage({ type: 'logout' });
});
// 无缝模式开关
elements.seamlessToggle.addEventListener('click', () => {
elements.seamlessToggle.classList.toggle('active');
const isEnabled = elements.seamlessToggle.classList.contains('active');
elements.seamlessAccounts.classList.toggle('hidden', !isEnabled);
vscode.postMessage({ type: 'updateSeamlessConfig', data: { enabled: isEnabled }});
});
// 代理开关
elements.proxyToggle.addEventListener('click', () => {
elements.proxyToggle.classList.toggle('active');
const isEnabled = elements.proxyToggle.classList.contains('active');
elements.proxyUrl.classList.toggle('hidden', !isEnabled);
elements.saveProxyBtn.classList.toggle('hidden', !isEnabled);
});
// 保存代理设置
elements.saveProxyBtn.addEventListener('click', () => {
const isEnabled = elements.proxyToggle.classList.contains('active');
const proxyUrl = elements.proxyUrl.value.trim();
vscode.postMessage({ type: 'updateProxyConfig', data: { isEnabled, proxyUrl }});
});
// 处理来自扩展的消息
window.addEventListener('message', event => {
const message = event.data;
switch (message.type) {
case 'onlineStatus':
updateConnectionStatus(message.isOnline);
break;
case 'verifyKeyResult':
handleVerifyResult(message.result);
break;
case 'storedKeyResult':
if (message.key) {
vscode.postMessage({ type: 'switchAccount', data: { key: message.key }});
}
break;
case 'switchAccountResult':
handleSwitchResult(message.result);
break;
case 'logoutResult':
handleLogout();
break;
case 'seamlessConfigResult':
handleSeamlessConfig(message.result);
break;
case 'proxyConfigResult':
handleProxyConfig(message.result);
break;
case 'error':
vscode.postMessage({ type: 'showMessage', data: { messageType: 'error', message: message.error }});
break;
}
});
function updateConnectionStatus(isOnline) {
elements.connectionStatus.className = 'status ' + (isOnline ? 'online' : 'offline');
elements.statusText.textContent = isOnline ? '已连接' : '连接断开';
}
function handleVerifyResult(result) {
elements.verifyBtn.disabled = false;
elements.verifyBtn.textContent = '验证激活码';
if (result.success) {
showLoggedIn(result.data);
vscode.postMessage({ type: 'showMessage', data: { messageType: 'info', message: '激活成功！' }});
} else {
vscode.postMessage({ type: 'showMessage', data: { messageType: 'error', message: result.message || '验证失败' }});
}
}
function handleSwitchResult(result) {
if (result.success) {
showLoggedIn(result.data);
vscode.postMessage({ type: 'showMessage', data: { messageType: 'info', message: '切换成功！' }});
} else {
vscode.postMessage({ type: 'showMessage', data: { messageType: 'error', message: result.message || '切换失败' }});
}
}
function showLoggedIn(data) {
elements.loginSection.classList.add('hidden');
elements.loggedInSection.classList.remove('hidden');
if (data) {
elements.requestCount.textContent = data.requestCount || 0;
elements.usageAmount.textContent = '$' + (data.usageAmount || 0).toFixed(2);
elements.accountEmail.textContent = data.email || '-';
elements.accountType.textContent = data.membership_type || 'Free';
}
}
function handleLogout() {
elements.loginSection.classList.remove('hidden');
elements.loggedInSection.classList.add('hidden');
elements.keyInput.value = '';
}
function handleSeamlessConfig(result) {
if (result.success && result.data) {
if (result.data.enabled) {
elements.seamlessToggle.classList.add('active');
elements.seamlessAccounts.classList.remove('hidden');
}
}
}
function handleProxyConfig(result) {
if (result.success && result.data) {
if (result.data.is_enabled) {
elements.proxyToggle.classList.add('active');
elements.proxyUrl.classList.remove('hidden');
elements.saveProxyBtn.classList.remove('hidden');
elements.proxyUrl.value = result.data.proxy_url || '';
}
}
}
// 初始化：获取存储的 key
vscode.postMessage({ type: 'getStoredKey' });
vscode.postMessage({ type: 'getSeamlessConfig' });
vscode.postMessage({ type: 'getProxyConfig' });
})();
</script>
</body>
</html>`;
}
/**
* 生成随机 nonce
*/
_getNonce() {
let text = '';
const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
for (let i = 0; i < 32; i++) {
text += possible.charAt(Math.floor(Math.random() * possible.length));
}
return text;
}
}
exports.CursorProProvider = CursorProProvider;