QLHazyCoder
508 lines
16 KiB
JavaScript
508 lines
16 KiB
JavaScript
(function attachBackgroundCpaApi(root, factory) {
|
||
root.MultiPageBackgroundCpaApi = factory();
|
||
})(typeof self !== 'undefined' ? self : globalThis, function createBackgroundCpaApiModule() {
|
||
function createCpaApi(deps = {}) {
|
||
const {
|
||
addLog = async () => {},
|
||
fetchImpl = (...args) => fetch(...args),
|
||
} = deps;
|
||
|
||
function normalizeString(value = '') {
|
||
return String(value || '').trim();
|
||
}
|
||
|
||
function isPlainObject(value) {
|
||
return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
|
||
}
|
||
|
||
function firstNonEmpty(...values) {
|
||
for (const value of values) {
|
||
const normalized = normalizeString(value);
|
||
if (normalized) {
|
||
return normalized;
|
||
}
|
||
}
|
||
return '';
|
||
}
|
||
|
||
function normalizeEmailValue(value = '') {
|
||
const email = normalizeString(value);
|
||
return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email) ? email : '';
|
||
}
|
||
|
||
function extractStateFromAuthUrl(authUrl = '') {
|
||
try {
|
||
return new URL(authUrl).searchParams.get('state') || '';
|
||
} catch {
|
||
return '';
|
||
}
|
||
}
|
||
|
||
function deriveCpaManagementOrigin(vpsUrl) {
|
||
const normalizedUrl = normalizeString(vpsUrl);
|
||
if (!normalizedUrl) {
|
||
throw new Error('尚未配置 CPA 地址，请先在侧边栏填写。');
|
||
}
|
||
let parsed;
|
||
try {
|
||
parsed = new URL(normalizedUrl);
|
||
} catch {
|
||
throw new Error('CPA 地址格式无效，请先在侧边栏检查。');
|
||
}
|
||
return parsed.origin;
|
||
}
|
||
|
||
function getCpaApiErrorMessage(payload, responseStatus = 500) {
|
||
const candidates = [
|
||
payload?.error,
|
||
payload?.message,
|
||
payload?.detail,
|
||
payload?.reason,
|
||
];
|
||
const message = candidates.map(normalizeString).find(Boolean);
|
||
return message || `CPA 管理接口请求失败（HTTP ${responseStatus}）。`;
|
||
}
|
||
|
||
async function fetchCpaManagementJson(origin, path, options = {}) {
|
||
const timeoutMs = Math.max(1000, Math.floor(Number(options.timeoutMs) || 20000));
|
||
const controller = new AbortController();
|
||
const timer = setTimeout(() => controller.abort(), timeoutMs);
|
||
|
||
try {
|
||
const managementKey = normalizeString(options.managementKey);
|
||
const headers = {
|
||
Accept: 'application/json',
|
||
'Content-Type': 'application/json',
|
||
};
|
||
if (managementKey) {
|
||
headers.Authorization = `Bearer ${managementKey}`;
|
||
headers['X-Management-Key'] = managementKey;
|
||
}
|
||
|
||
const response = await fetchImpl(`${origin}${path}`, {
|
||
method: options.method || 'POST',
|
||
headers,
|
||
body: options.body === undefined ? undefined : JSON.stringify(options.body),
|
||
signal: controller.signal,
|
||
});
|
||
|
||
let payload = {};
|
||
try {
|
||
payload = await response.json();
|
||
} catch {
|
||
payload = {};
|
||
}
|
||
|
||
if (!response.ok) {
|
||
throw new Error(getCpaApiErrorMessage(payload, response.status));
|
||
}
|
||
|
||
return payload;
|
||
} catch (error) {
|
||
if (error?.name === 'AbortError') {
|
||
throw new Error('CPA 管理接口请求超时，请稍后重试。');
|
||
}
|
||
throw error;
|
||
} finally {
|
||
clearTimeout(timer);
|
||
}
|
||
}
|
||
|
||
function decodeBase64UrlSegment(segment = '') {
|
||
const normalized = normalizeString(segment)
|
||
.replace(/-/g, '+')
|
||
.replace(/_/g, '/');
|
||
if (!normalized) {
|
||
return '';
|
||
}
|
||
const padded = normalized + '='.repeat((4 - (normalized.length % 4)) % 4);
|
||
try {
|
||
if (typeof Buffer !== 'undefined') {
|
||
return Buffer.from(padded, 'base64').toString('utf8');
|
||
}
|
||
if (typeof atob === 'function') {
|
||
const binary = atob(padded);
|
||
const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
|
||
if (typeof TextDecoder !== 'undefined') {
|
||
return new TextDecoder().decode(bytes);
|
||
}
|
||
return binary;
|
||
}
|
||
} catch {
|
||
return '';
|
||
}
|
||
return '';
|
||
}
|
||
|
||
function encodeBase64UrlJson(value) {
|
||
const json = JSON.stringify(value);
|
||
if (typeof Buffer !== 'undefined') {
|
||
return Buffer.from(json, 'utf8')
|
||
.toString('base64')
|
||
.replace(/\+/g, '-')
|
||
.replace(/\//g, '_')
|
||
.replace(/=+$/g, '');
|
||
}
|
||
const bytes = new TextEncoder().encode(json);
|
||
let binary = '';
|
||
bytes.forEach((byte) => {
|
||
binary += String.fromCharCode(byte);
|
||
});
|
||
return btoa(binary)
|
||
.replace(/\+/g, '-')
|
||
.replace(/\//g, '_')
|
||
.replace(/=+$/g, '');
|
||
}
|
||
|
||
function parseJwtPayload(token = '') {
|
||
const normalized = normalizeString(token);
|
||
if (!normalized) {
|
||
return null;
|
||
}
|
||
const parts = normalized.split('.');
|
||
if (parts.length < 2) {
|
||
return null;
|
||
}
|
||
try {
|
||
return JSON.parse(decodeBase64UrlSegment(parts[1]));
|
||
} catch {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
function getOpenAiAuthSection(payload) {
|
||
if (!isPlainObject(payload)) {
|
||
return {};
|
||
}
|
||
const auth = payload['https://api.openai.com/auth'];
|
||
return isPlainObject(auth) ? auth : {};
|
||
}
|
||
|
||
function getOpenAiProfileSection(payload) {
|
||
if (!isPlainObject(payload)) {
|
||
return {};
|
||
}
|
||
const profile = payload['https://api.openai.com/profile'];
|
||
return isPlainObject(profile) ? profile : {};
|
||
}
|
||
|
||
function normalizeTimestamp(value) {
|
||
if (value instanceof Date && !Number.isNaN(value.getTime())) {
|
||
return value.toISOString();
|
||
}
|
||
if (typeof value === 'number' && Number.isFinite(value)) {
|
||
const milliseconds = value > 1e11 ? value : value * 1000;
|
||
const date = new Date(milliseconds);
|
||
return Number.isNaN(date.getTime()) ? '' : date.toISOString();
|
||
}
|
||
if (typeof value !== 'string' || !value.trim()) {
|
||
return '';
|
||
}
|
||
const date = new Date(value);
|
||
return Number.isNaN(date.getTime()) ? '' : date.toISOString();
|
||
}
|
||
|
||
function timestampFromUnixSeconds(value) {
|
||
const numeric = Number(value);
|
||
if (!Number.isFinite(numeric)) {
|
||
return '';
|
||
}
|
||
const date = new Date(numeric * 1000);
|
||
return Number.isNaN(date.getTime()) ? '' : date.toISOString();
|
||
}
|
||
|
||
function epochSecondsFromValue(value) {
|
||
if (value === undefined || value === null || value === '') {
|
||
return 0;
|
||
}
|
||
const numeric = Number(value);
|
||
if (Number.isFinite(numeric)) {
|
||
return Math.trunc(numeric > 1e11 ? numeric / 1000 : numeric);
|
||
}
|
||
const parsed = Date.parse(String(value));
|
||
return Number.isFinite(parsed) ? Math.trunc(parsed / 1000) : 0;
|
||
}
|
||
|
||
function buildSyntheticCodexIdToken(email, accountId, planType, userId, expiresAt) {
|
||
const normalizedAccountId = normalizeString(accountId);
|
||
if (!normalizedAccountId) {
|
||
return '';
|
||
}
|
||
const now = Math.trunc(Date.now() / 1000);
|
||
const expires = epochSecondsFromValue(expiresAt) || now + 90 * 24 * 60 * 60;
|
||
const authInfo = { chatgpt_account_id: normalizedAccountId };
|
||
|
||
if (planType) {
|
||
authInfo.chatgpt_plan_type = normalizeString(planType);
|
||
}
|
||
if (userId) {
|
||
authInfo.chatgpt_user_id = normalizeString(userId);
|
||
authInfo.user_id = normalizeString(userId);
|
||
}
|
||
|
||
const payload = {
|
||
iat: now,
|
||
exp: expires,
|
||
'https://api.openai.com/auth': authInfo,
|
||
};
|
||
if (email) {
|
||
payload.email = normalizeString(email);
|
||
}
|
||
|
||
return `${encodeBase64UrlJson({ alg: 'none', typ: 'JWT', cpa_synthetic: true })}.${encodeBase64UrlJson(payload)}.synthetic`;
|
||
}
|
||
|
||
function normalizePlanTypeForFileName(planType = '') {
|
||
return normalizeString(planType)
|
||
.split(/[^a-zA-Z0-9]+/)
|
||
.map((part) => part.trim().toLowerCase())
|
||
.filter(Boolean)
|
||
.join('-');
|
||
}
|
||
|
||
function sanitizeFileSegment(value = '', fallback = 'chatgpt-session') {
|
||
const normalized = normalizeString(value)
|
||
.replace(/[\\/:*?"<>|]+/g, '-')
|
||
.replace(/\s+/g, '-')
|
||
.replace(/-+/g, '-')
|
||
.replace(/^-+|-+$/g, '');
|
||
return normalized || fallback;
|
||
}
|
||
|
||
function buildCpaAuthFileName(metadata = {}) {
|
||
const email = sanitizeFileSegment(metadata.email || '');
|
||
const planType = normalizePlanTypeForFileName(metadata.planType || '');
|
||
const accountId = sanitizeFileSegment(metadata.accountId || '');
|
||
if (email && planType) {
|
||
return `codex-${email}-${planType}.json`;
|
||
}
|
||
if (email) {
|
||
return `codex-${email}.json`;
|
||
}
|
||
if (accountId && planType) {
|
||
return `codex-${accountId}-${planType}.json`;
|
||
}
|
||
if (accountId) {
|
||
return `codex-${accountId}.json`;
|
||
}
|
||
return `codex-${Date.now()}.json`;
|
||
}
|
||
|
||
function buildCpaSessionAuthJson(state = {}, options = {}) {
|
||
const session = isPlainObject(state?.session) ? state.session : {};
|
||
const accessToken = normalizeString(state?.accessToken || session?.accessToken);
|
||
if (!accessToken) {
|
||
throw new Error('未读取到可导入的 ChatGPT accessToken。');
|
||
}
|
||
|
||
const inputIdToken = firstNonEmpty(
|
||
state?.idToken,
|
||
state?.id_token,
|
||
session?.idToken,
|
||
session?.id_token
|
||
);
|
||
const refreshToken = firstNonEmpty(
|
||
state?.refreshToken,
|
||
state?.refresh_token,
|
||
session?.refreshToken,
|
||
session?.refresh_token
|
||
);
|
||
const sessionToken = firstNonEmpty(
|
||
state?.sessionToken,
|
||
state?.session_token,
|
||
session?.sessionToken,
|
||
session?.session_token
|
||
);
|
||
const accessPayload = parseJwtPayload(accessToken);
|
||
const idPayload = parseJwtPayload(inputIdToken);
|
||
const accessAuth = getOpenAiAuthSection(accessPayload);
|
||
const idAuth = getOpenAiAuthSection(idPayload);
|
||
const profile = getOpenAiProfileSection(accessPayload);
|
||
const expiresAt = firstNonEmpty(
|
||
timestampFromUnixSeconds(accessPayload?.exp),
|
||
normalizeTimestamp(session?.expires),
|
||
normalizeTimestamp(session?.expiresAt),
|
||
normalizeTimestamp(session?.expired),
|
||
normalizeTimestamp(session?.expires_at)
|
||
);
|
||
const accountIdentifierEmail = normalizeString(state?.accountIdentifierType).toLowerCase() === 'email'
|
||
? normalizeEmailValue(state?.accountIdentifier)
|
||
: '';
|
||
const email = firstNonEmpty(
|
||
normalizeEmailValue(session?.user?.email),
|
||
normalizeEmailValue(session?.email),
|
||
normalizeEmailValue(state?.email),
|
||
accountIdentifierEmail,
|
||
normalizeEmailValue(profile?.email),
|
||
normalizeEmailValue(idPayload?.email),
|
||
normalizeEmailValue(accessPayload?.email)
|
||
);
|
||
const accountId = firstNonEmpty(
|
||
session?.account?.id,
|
||
session?.account_id,
|
||
accessAuth?.chatgpt_account_id,
|
||
idAuth?.chatgpt_account_id
|
||
);
|
||
const userId = firstNonEmpty(
|
||
session?.user?.id,
|
||
session?.user_id,
|
||
accessAuth?.chatgpt_user_id,
|
||
accessAuth?.user_id,
|
||
idAuth?.chatgpt_user_id,
|
||
idAuth?.user_id
|
||
);
|
||
const planType = firstNonEmpty(
|
||
session?.account?.planType,
|
||
session?.account?.plan_type,
|
||
session?.planType,
|
||
session?.plan_type,
|
||
accessAuth?.chatgpt_plan_type,
|
||
idAuth?.chatgpt_plan_type
|
||
);
|
||
const exportedAt = normalizeTimestamp(options.now || new Date()) || new Date().toISOString();
|
||
const syntheticIdToken = inputIdToken
|
||
? ''
|
||
: buildSyntheticCodexIdToken(email, accountId, planType, userId, expiresAt);
|
||
const idToken = inputIdToken || syntheticIdToken;
|
||
const authJson = Object.fromEntries(
|
||
Object.entries({
|
||
type: 'codex',
|
||
account_id: accountId,
|
||
chatgpt_account_id: accountId,
|
||
email,
|
||
name: firstNonEmpty(email, state?.email, 'ChatGPT Account'),
|
||
plan_type: planType,
|
||
chatgpt_plan_type: planType,
|
||
id_token: idToken,
|
||
id_token_synthetic: syntheticIdToken ? true : undefined,
|
||
access_token: accessToken,
|
||
refresh_token: refreshToken || '',
|
||
session_token: sessionToken,
|
||
last_refresh: exportedAt,
|
||
expired: expiresAt,
|
||
disabled: session?.disabled === true ? true : undefined,
|
||
}).filter(([, value]) => value !== undefined && value !== null && value !== '')
|
||
);
|
||
|
||
return {
|
||
authJson,
|
||
accountId,
|
||
email,
|
||
expiresAt,
|
||
fileName: buildCpaAuthFileName({ email, planType, accountId }),
|
||
hasRefreshToken: Boolean(refreshToken),
|
||
};
|
||
}
|
||
|
||
async function logWithOptions(message, level = 'info', options = {}) {
|
||
await addLog(message, level, options.logOptions || {});
|
||
}
|
||
|
||
async function requestOAuthUrl(state, options = {}) {
|
||
const managementKey = normalizeString(state?.vpsPassword);
|
||
if (!managementKey) {
|
||
throw new Error('尚未配置 CPA 管理密钥，请先在侧边栏填写。');
|
||
}
|
||
const origin = deriveCpaManagementOrigin(state?.vpsUrl);
|
||
const result = await fetchCpaManagementJson(origin, '/v0/management/codex-auth-url', {
|
||
method: 'GET',
|
||
managementKey,
|
||
timeoutMs: options.timeoutMs,
|
||
});
|
||
const oauthUrl = firstNonEmpty(
|
||
result?.url,
|
||
result?.auth_url,
|
||
result?.authUrl,
|
||
result?.data?.url,
|
||
result?.data?.auth_url,
|
||
result?.data?.authUrl
|
||
);
|
||
const oauthState = firstNonEmpty(
|
||
result?.state,
|
||
result?.auth_state,
|
||
result?.authState,
|
||
result?.data?.state,
|
||
result?.data?.auth_state,
|
||
result?.data?.authState,
|
||
extractStateFromAuthUrl(oauthUrl)
|
||
);
|
||
|
||
if (!oauthUrl || !oauthUrl.startsWith('http')) {
|
||
throw new Error('CPA 管理接口未返回有效的 auth_url。');
|
||
}
|
||
|
||
return {
|
||
oauthUrl,
|
||
cpaOAuthState: oauthState || null,
|
||
cpaManagementOrigin: origin,
|
||
};
|
||
}
|
||
|
||
async function submitOAuthCallback(state, callbackUrl, options = {}) {
|
||
const managementKey = normalizeString(state?.vpsPassword);
|
||
if (!managementKey) {
|
||
throw new Error('尚未配置 CPA 管理密钥，请先在侧边栏填写。');
|
||
}
|
||
const origin = normalizeString(state?.cpaManagementOrigin) || deriveCpaManagementOrigin(state?.vpsUrl);
|
||
const result = await fetchCpaManagementJson(origin, '/v0/management/oauth-callback', {
|
||
method: 'POST',
|
||
managementKey,
|
||
timeoutMs: options.timeoutMs,
|
||
body: {
|
||
provider: 'codex',
|
||
redirect_url: normalizeString(callbackUrl),
|
||
},
|
||
});
|
||
return {
|
||
localhostUrl: normalizeString(callbackUrl),
|
||
verifiedStatus: firstNonEmpty(result?.message, result?.status_message, 'CPA 已通过接口提交回调'),
|
||
};
|
||
}
|
||
|
||
async function importCurrentChatGptSession(state = {}, options = {}) {
|
||
const logLabel = normalizeString(options.logLabel) || 'CPA 会话导入';
|
||
const managementKey = normalizeString(state?.vpsPassword);
|
||
if (!managementKey) {
|
||
throw new Error('尚未配置 CPA 管理密钥，请先在侧边栏填写。');
|
||
}
|
||
const origin = deriveCpaManagementOrigin(state?.vpsUrl);
|
||
const sessionAuth = buildCpaSessionAuthJson(state, options);
|
||
|
||
await logWithOptions(`${logLabel}：正在通过 CPA 管理接口导入当前 ChatGPT 会话...`, 'info', options);
|
||
if (!sessionAuth.hasRefreshToken) {
|
||
await logWithOptions(`${logLabel}：未包含 refresh_token，access_token 过期后无法自动续期。`, 'warn', options);
|
||
}
|
||
|
||
await fetchCpaManagementJson(origin, `/v0/management/auth-files?name=${encodeURIComponent(sessionAuth.fileName)}`, {
|
||
method: 'POST',
|
||
managementKey,
|
||
timeoutMs: options.importTimeoutMs || options.timeoutMs,
|
||
body: sessionAuth.authJson,
|
||
});
|
||
|
||
const verifiedStatus = sessionAuth.email
|
||
? `CPA 会话导入完成：${sessionAuth.email}`
|
||
: `CPA 会话导入完成：${sessionAuth.fileName}`;
|
||
await logWithOptions(verifiedStatus, 'ok', options);
|
||
return {
|
||
verifiedStatus,
|
||
cpaImportedFileName: sessionAuth.fileName,
|
||
cpaImportedEmail: sessionAuth.email || null,
|
||
};
|
||
}
|
||
|
||
return {
|
||
buildCpaSessionAuthJson,
|
||
deriveCpaManagementOrigin,
|
||
fetchCpaManagementJson,
|
||
importCurrentChatGptSession,
|
||
requestOAuthUrl,
|
||
submitOAuthCallback,
|
||
};
|
||
}
|
||
|
||
return {
|
||
createCpaApi,
|
||
};
|
||
});
|