mirror of
https://wget.la/https://github.com/432539/gpt
synced 2026-08-17 03:26:59 +08:00
432539
fef45134d5
只开源「GPT 账号注册机 / 管理」(account-manager)：账号列表/导入导出、检测/批量检测、 拿 RT、协议/浏览器注册等注册机能力。批量直开 / 协议支付 / 提取链接 / 直卡直开 等其它功能 不含实现代码，仅通过 iframe 内嵌外链访问。真实机密均由 .gitignore 忽略，仅提供脱敏示例配置。
1468 lines
84 KiB
JavaScript
1468 lines
84 KiB
JavaScript
// 浏览器注册 wrapper —— 用 CloakBrowser（隐身 Chromium，指纹在 C++ 源码层随机，开箱即用）
|
||
// 驱动真实 ChatGPT / OpenAI 注册 UI 完成注册，作为「账号注册」的第二种方式（第一种是
|
||
// get-rt.js 的 HTTP 协议注册）。设计上与协议注册共用同一套外围资源：
|
||
// · 代理池：由 Python 侧随机选一个代理，注入 CloakBrowser 的 proxy（http://user:pass@host:port）；
|
||
// · 邮箱池 OTP：验证码依旧从 Flask /api/reg/inbox 读（IMAP / 取件API），与协议模式同一数据源；
|
||
// · 接码：需要手机验证时复用 smscode / smsbower / hero-sms 模块（按 settings.sms.provider）；
|
||
// · 日志：逐行 JSON 写 stderr（{level,msg,account}），沿用协议注册那套中文短语，前端浮层直接展示；
|
||
// · 结果：stdout 输出一段 JSON（形状对齐 reg_runner），由 Python 的 _save_registered_account 落库。
|
||
//
|
||
// 为什么这样拿 RT：浏览器完成注册后即持有 auth.openai.com 的登录会话（cookie）。我们让浏览器
|
||
// 从 codex 客户端的 /oauth/authorize（PKCE）开始，注册收尾时服务端会 302 到
|
||
// redirect_uri=http://localhost:1455/auth/callback?code=…。我们用 route 拦截这个跳转拿到
|
||
// authorization code，再用同一 context（同 cookie/同代理）POST /oauth/token 换 refresh_token。
|
||
// 这与协议模式换 RT 的原理一致，区别只是「授权页由真实浏览器走完」。
|
||
//
|
||
// 输入（stdin JSON）：{ email, settings, proxy, otpBase, headless, licenseKey, password? }
|
||
// 输出（stdout JSON）：成功 { ok:true, refreshToken, accessToken, clientId, password, subOk:false }
|
||
// 失败 { ok:false, registered?, banned?, error }
|
||
import crypto from 'node:crypto';
|
||
import { appendFileSync } from 'node:fs';
|
||
import { fileURLToPath } from 'node:url';
|
||
import path from 'node:path';
|
||
import { launchContext } from 'cloakbrowser';
|
||
|
||
// 2FA 诊断落文件：Flask 侧 _pump_stderr 会过滤 [ 开头的诊断行，导致真实 E2E 注册流里的 2FA
|
||
// 分支信息看不到。这里把 [2FA-DIAG] 同步追加到固定文件，事后可读，定位「新会话点开关后 enroll
|
||
// 对话框到底出没出」。仅诊断用，稳定后可移除。
|
||
const _2FA_DIAG_FILE = path.join(path.dirname(fileURLToPath(import.meta.url)), '_2fa_diag.log');
|
||
function diag2fa(msg) {
|
||
const line = `[2FA-DIAG] ${new Date().toISOString()} ${msg}`;
|
||
try { process.stderr.write(line + '\n'); } catch { /* */ }
|
||
try { appendFileSync(_2FA_DIAG_FILE, line + '\n'); } catch { /* */ }
|
||
}
|
||
import { extractCode } from './plus-mailbox.js';
|
||
import { resolveRegPassword } from './reg_password.mjs';
|
||
import { generateFingerprint } from './fingerprint.js';
|
||
import * as smscode from './smscode.js';
|
||
import * as smsbower from './smsbower.js';
|
||
import * as herosms from './hero-sms.js';
|
||
|
||
// —— stdout 纪律：CloakBrowser / 底层库可能往 stdout 打印（下载进度、告警），会污染结果 JSON。
|
||
// 把 console.* 与「非结果」的 stdout 全部改道 stderr，最终结果用保存的原始 writer 独占 stdout。
|
||
const realStdoutWrite = process.stdout.write.bind(process.stdout);
|
||
process.stdout.write = process.stderr.write.bind(process.stderr);
|
||
const _errWrite = (...a) => { try { process.stderr.write(a.map(String).join(' ') + '\n'); } catch { /* ignore */ } };
|
||
console.log = _errWrite;
|
||
console.info = _errWrite;
|
||
console.warn = _errWrite;
|
||
console.debug = _errWrite;
|
||
|
||
const OAUTH_ISSUER = 'https://auth.openai.com';
|
||
// codex 客户端：/oauth/authorize?screen_hint=signup 直达注册，但 codex 授权流会强制手机验证
|
||
//（这是我们一直卡手机、skip-phone 拿不到 AT 的根因）。仅保留给「后续绑手机拿 RT」用。
|
||
const OAUTH_CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
|
||
const OAUTH_REDIRECT_URI = 'http://localhost:1455/auth/callback';
|
||
const OAUTH_SCOPE = 'openid profile email offline_access';
|
||
// ChatGPT 网页客户端（来自真实抓包 8.3chatgpt.com.har）：走 chatgpt.com 普通 signup，
|
||
// 一般不强制手机，注册完成即在 chatgpt.com 建立登录态 → 能直接拿「会话 cookie(CK)+网页 AT」。
|
||
// 手机 + codex RT 留到后续「批量绑手机拿RT」再做。
|
||
const WEB_CLIENT_ID = 'app_X8zY6vW2pQ9tR3dE7nK1jL5gH';
|
||
const WEB_REDIRECT_URI = 'https://chatgpt.com/api/auth/callback/openai';
|
||
const WEB_SCOPE = 'openid email profile offline_access model.request model.read organization.read organization.write';
|
||
|
||
function readStdin() {
|
||
return new Promise((resolve) => {
|
||
let buf = '';
|
||
process.stdin.setEncoding('utf8');
|
||
process.stdin.on('data', (c) => { buf += c; });
|
||
process.stdin.on('end', () => resolve(buf));
|
||
});
|
||
}
|
||
function emitLog(level, msg, account) {
|
||
try { process.stderr.write(JSON.stringify({ level, msg: String(msg), account: account || '' }) + '\n'); } catch { /* ignore */ }
|
||
}
|
||
function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
|
||
|
||
// 随机成年生日 YYYY-MM-DD（18~48 岁），与 fingerprint.randomAdultBirthdate 口径一致。
|
||
function randomAdultBirthdate() {
|
||
const nowYear = new Date().getUTCFullYear();
|
||
const age = 18 + crypto.randomInt(0, 31);
|
||
const month = 1 + crypto.randomInt(0, 12);
|
||
const day = 1 + crypto.randomInt(0, 28);
|
||
return `${nowYear - age}-${String(month).padStart(2, '0')}-${String(day).padStart(2, '0')}`;
|
||
}
|
||
const FIRST = ['James', 'Michael', 'David', 'Emily', 'Emma', 'Olivia', 'Daniel', 'Sarah', 'Grace', 'Ryan', 'Laura', 'Nathan'];
|
||
const LAST = ['Smith', 'Johnson', 'Brown', 'Miller', 'Davis', 'Wilson', 'Moore', 'Taylor', 'Anderson', 'Clark', 'Walker', 'Young'];
|
||
function randomFullName() { return `${FIRST[crypto.randomInt(0, FIRST.length)]} ${LAST[crypto.randomInt(0, LAST.length)]}`; }
|
||
|
||
// smsbower / sms-activate 的国家 id → { iso2, dial }。覆盖 settings 里配置的候选（越南/肯尼亚/
|
||
// 印尼/美国/菲律宾/阿根廷）+ 常见国家。用途：接码平台返回的号码是「含国码的完整号」，而 OpenAI
|
||
// 手机页默认停在美国 +1，必须按号码所属国家把页面上的国家选对，否则号码与国码对不上、永远收不到码。
|
||
const SMS_COUNTRY = {
|
||
0: { iso2: 'ru', dial: '7' }, 4: { iso2: 'ph', dial: '63' }, 6: { iso2: 'id', dial: '62' },
|
||
8: { iso2: 'ke', dial: '254' }, 10: { iso2: 'vn', dial: '84' }, 16: { iso2: 'gb', dial: '44' },
|
||
22: { iso2: 'in', dial: '91' }, 36: { iso2: 'ca', dial: '1' }, 39: { iso2: 'ar', dial: '54' },
|
||
187: { iso2: 'us', dial: '1' },
|
||
};
|
||
// 常见国码（做「号码前缀最长匹配」剥离国码，得到本国号；hintDial 优先）。
|
||
const DIAL_CODES = ['1', '7', '20', '27', '33', '34', '39', '44', '49', '52', '54', '55', '60', '61', '62', '63', '66', '81', '84', '90', '91', '234', '254', '351', '380', '852', '886'];
|
||
function splitDial(digits, hintDial) {
|
||
const d = String(digits || '');
|
||
if (hintDial && d.startsWith(hintDial)) return { dial: hintDial, national: d.slice(hintDial.length) };
|
||
for (const c of [...DIAL_CODES].sort((a, b) => b.length - a.length)) {
|
||
if (d.startsWith(c)) return { dial: c, national: d.slice(c.length) };
|
||
}
|
||
return { dial: '', national: d };
|
||
}
|
||
|
||
// 把 Python 传来的 proxy 对象转成 CloakBrowser/Playwright 认的字符串（与 get-rt.js getProxyAgent 同构）。
|
||
function proxyToString(proxy) {
|
||
if (!proxy || !proxy.host || !proxy.port) return undefined;
|
||
const auth = proxy.username
|
||
? `${encodeURIComponent(proxy.username)}:${encodeURIComponent(proxy.password || '')}@`
|
||
: '';
|
||
return `http://${auth}${proxy.host}:${proxy.port}`;
|
||
}
|
||
|
||
// PKCE（与协议模式一致）。
|
||
function generatePkce() {
|
||
const verifier = crypto.randomBytes(64).toString('base64url');
|
||
const challenge = crypto.createHash('sha256').update(verifier).digest('base64url');
|
||
return { verifier, challenge };
|
||
}
|
||
|
||
// ==================== UI 小工具（尽量鲁棒，找不到就返回 null，不抛错） ====================
|
||
// 返回第一个「可见」的定位器。提速：不再对每个候选各等满 timeout（N 个选择器最坏 N×timeout），
|
||
// 改为在 timeout 内轮询所有候选、命中即返回，总耗时被 timeout 封顶；不存在时也快速返回。
|
||
async function firstVisible(page, selectors, timeout = 1200) {
|
||
const deadline = Date.now() + timeout;
|
||
for (;;) {
|
||
for (const sel of selectors) {
|
||
try {
|
||
const loc = page.locator(sel).first();
|
||
if (await loc.isVisible()) return loc;
|
||
} catch { /* 试下一个 */ }
|
||
}
|
||
if (Date.now() >= deadline) return null;
|
||
await sleep(120);
|
||
}
|
||
}
|
||
|
||
// 建号后兜底定位「验证码输入框」：精确选择器失配时，取首个可见/可编辑/为空、且非
|
||
// password/email/tel 的输入框（此阶段唯一要输入的就是邮箱验证码）。返回 locator 或 null。
|
||
async function findGenericOtpBox(page) {
|
||
const cand = page.locator(
|
||
'input:not([type="hidden"]):not([type="checkbox"]):not([type="radio"]):not([type="submit"]):not([type="button"]):not([type="password"]):not([type="email"]):not([type="tel"])',
|
||
);
|
||
const n = await cand.count().catch(() => 0);
|
||
for (let i = 0; i < n; i++) {
|
||
const el = cand.nth(i);
|
||
try {
|
||
if (!(await el.isVisible())) continue;
|
||
if (!(await el.isEnabled())) continue;
|
||
if ((await el.getAttribute('readonly')) !== null) continue;
|
||
if (String(await el.inputValue().catch(() => '')).trim() !== '') continue;
|
||
return el;
|
||
} catch { /* 试下一个 */ }
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// 提交当前步：优先点主提交按钮 / 精确文案 "Continue"（用 text-is 精确匹配，避免误点
|
||
// "Continue with Google/Apple/Microsoft" 这些第三方登录按钮），否则回退按回车提交表单。
|
||
async function submitStep(page) {
|
||
const btn = await firstVisible(page, [
|
||
'button[type="submit"]',
|
||
'button:text-is("Continue")',
|
||
'button:text-is("Next")',
|
||
'button:text-is("Sign up")',
|
||
], 1500);
|
||
if (btn) { await btn.click().catch(() => {}); return; }
|
||
await page.keyboard.press('Enter').catch(() => {});
|
||
}
|
||
|
||
// 提交某步后让页面稳定再判定：等 DOM 就绪 + 极短延时。提速：真正的「离开该步」判定交给
|
||
// waitLeaveType 用条件轮询处理，这里只做一次轻量稳定（1200ms→350ms），不再固定长等。
|
||
async function settle(page) {
|
||
try { await page.waitForLoadState('domcontentloaded', { timeout: 6000 }); } catch { /* ignore */ }
|
||
await sleep(350);
|
||
}
|
||
|
||
// 提交某步后等页面「真正离开该步」再继续——OpenAI 是 SPA，提交后同一页会先进入「校验/跳转中」
|
||
// 的过渡态（输入框被禁用/仍带旧值），若立即重新判定会把过渡页当成同一步二次处理（历史 bug：
|
||
// 邮箱验证通过后又回到验证码分支、对已禁用的框重填而报「未能填入」）。轮询到类型变化即返回。
|
||
async function waitLeaveType(page, type, ms = 20000) {
|
||
const start = Date.now();
|
||
// 提速：轮询间隔 1000ms→400ms，页面一离开该步立即返回；仍保留最大超时上限防卡死。
|
||
while (Date.now() - start < ms) {
|
||
await sleep(400);
|
||
const t = classifyPage(await detectPage(page));
|
||
if (t !== type) return t;
|
||
}
|
||
return type;
|
||
}
|
||
|
||
// 把当前页可见输入框/按钮/URL 转储到 stderr（原始行），便于按真实 DOM 校准选择器。
|
||
async function dumpDiag(page) {
|
||
try {
|
||
const diag = await page.evaluate(() => {
|
||
const ins = [...document.querySelectorAll('input')]
|
||
.filter((i) => i.offsetParent !== null)
|
||
.map((i) => `${i.name || i.id || '?'}|${i.type}|im=${i.getAttribute('inputmode') || ''}|ac=${i.getAttribute('autocomplete') || ''}|ml=${i.getAttribute('maxlength') || ''}`);
|
||
const btns = [...document.querySelectorAll('button')].map((b) => (b.innerText || '').trim()).filter(Boolean);
|
||
return { url: location.href, title: document.title || '', text: (document.body && document.body.innerText || '').replace(/\s+/g, ' ').slice(0, 200), inputs: ins, buttons: btns };
|
||
});
|
||
process.stderr.write(`[CLOAK-DIAG] ${JSON.stringify(diag)}\n`);
|
||
} catch { /* ignore */ }
|
||
}
|
||
|
||
// ==================== 页面判定：严格按「当前页面真实特征」识别处于哪一步 ====================
|
||
// 教训：不能靠「有没有 Continue 按钮 + 步骤标志位」顺着走——OTP/密码页也有 Continue 按钮，
|
||
// 会被误当授权页空点，从而跳过邮箱验证码/手机验证，最终被带到登录页报「密码错误」。
|
||
// detectPage 一次性在页面上下文里统计各类输入是否可见、是否还有「可填空输入」、授权按钮/语境、
|
||
// 以及「密码错误 / 邮箱已注册」等硬信号；classifyPage 据此 + URL 判定当前步骤。
|
||
async function detectPage(page) {
|
||
let url = '';
|
||
try { url = page.url(); } catch { /* ignore */ }
|
||
const dom = await page.evaluate(() => {
|
||
const vis = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
|
||
const qa = (s) => [...document.querySelectorAll(s)];
|
||
const cnt = (s) => qa(s).filter(vis).length;
|
||
const bad = new Set(['hidden', 'checkbox', 'radio', 'submit', 'button', 'image', 'reset', 'file']);
|
||
// 是否还有「可见 / 可编辑 / 非只读 / 值为空」的待填输入——授权分支必须为 false 才允许点。
|
||
const anyFillable = qa('input, textarea').some((i) => {
|
||
if (!vis(i)) return false;
|
||
if (i.disabled || i.readOnly) return false;
|
||
const t = (i.getAttribute('type') || 'text').toLowerCase();
|
||
if (bad.has(t)) return false;
|
||
return String(i.value || '').trim() === '';
|
||
});
|
||
const email = cnt('input[type="email"], input[name="email"], input#email-input, input[autocomplete="username"], input[placeholder*="email" i]');
|
||
const pw = cnt('input[type="password"], input[name="password"], input[name="new-password"]');
|
||
const tel = cnt('input[type="tel"], input[name="phone"], input[name="phone_number"], input[autocomplete="tel"]');
|
||
const otp = cnt('input[autocomplete="one-time-code"], input[name="code"], input[name="otp"], input[inputmode="numeric"], input[maxlength="1"], input[maxlength="6"], [role="textbox"][aria-label*="code" i]');
|
||
const name = cnt('input[name="name"], input#name, input[autocomplete="name"], input[placeholder*="name" i]');
|
||
const bday = cnt('input[type="date"], input[name="birthdate"], input[name="bday"], input[placeholder*="birth" i]');
|
||
const btnTexts = qa('button, [role="button"], input[type="submit"]').filter(vis)
|
||
.map((b) => (b.innerText || b.value || '').trim().toLowerCase()).filter(Boolean);
|
||
const authorizeBtn = btnTexts.some((t) => /^(authorize|allow|agree|yes,|continue to)/.test(t) || /\bauthorize\b/.test(t));
|
||
const continueBtn = btnTexts.some((t) => /^(continue|next)\b/.test(t)) || cnt('button[type="submit"]') > 0;
|
||
const text = (document.body && document.body.innerText || '').toLowerCase();
|
||
const wrongCred = /incorrect email address or password|that password is incorrect|wrong password/.test(text);
|
||
const emailTaken = /already (has|have) an account|already exists|use a different email/.test(text);
|
||
const mentionsPhone = /phone number|text message|\bsms\b|mobile number|verify your phone/.test(text);
|
||
const mentionsEmailCode = /check your (inbox|email)|sent .{0,20}to your email|verify your email|enter the code .{0,20}email/.test(text);
|
||
const consentText = /want[s]? to access|is requesting access|authorize .{0,20}(app|access)|by (continuing|authorizing)/.test(text);
|
||
// 账号选择页（bindPhone 恢复会话后发起 codex 授权时会出现）：「Choose an account to continue to …」，
|
||
// 页面无输入、只有账号磁贴/「Select account」，需点磁贴才继续到授权。用文本 + URL 双信号识别。
|
||
const chooseAccount = /choose an account to continue|select account/.test(text);
|
||
// about-you 强文本信号：「how old are you / full name / finish creating account / date of birth」等。
|
||
// 用途：变体A 的 Age(整数)输入会命中 inputmode=numeric 而被误判成验证码页，故用此强信号在
|
||
// classifyPage 里抢先判为 about_you，避免走到「等邮箱验证码」的错误分支。
|
||
const aboutYou = /how old are you|finish creating account|full name|tell us about you|what'?s your name|date of birth/.test(text);
|
||
return { email, pw, tel, otp, name, bday, anyFillable, authorizeBtn, continueBtn, wrongCred, emailTaken, mentionsPhone, mentionsEmailCode, consentText, aboutYou, chooseAccount };
|
||
}).catch(() => null);
|
||
return { url, dom };
|
||
}
|
||
|
||
// 按特征强弱判定当前步：手机 → 验证码 → 密码 → 邮箱 → 补资料 → 授权 → 过渡 → 未知。
|
||
// 只有「无任何可填输入 + 授权按钮/授权语境」才判为 consent（真·授权页）；无输入但只有普通
|
||
// Continue、又无授权语境的，判为 interstitial（过渡页，稳定后才点）——绝不在有输入的页上点授权。
|
||
function classifyPage({ url, dom }) {
|
||
if (!dom) return 'loading';
|
||
const u = String(url || '').toLowerCase();
|
||
if (u.includes('localhost:1455')) return 'callback';
|
||
// 账号选择页：URL 或文本任一命中即判定（无输入、需点账号磁贴）。放在最前，避免落到 unknown。
|
||
if (u.includes('choose-an-account') || dom.chooseAccount) return 'choose_account';
|
||
// about-you 抢先判定（无密码/无电话时）：变体A 的 Age 数字框会误命中 OTP 选择器，用强文本信号先兜住。
|
||
if (dom.aboutYou && dom.pw === 0 && dom.tel === 0) return 'about_you';
|
||
if (dom.tel > 0) return 'phone';
|
||
if (dom.otp > 0 && dom.pw === 0) {
|
||
const phoneCtx = /add-phone|phone-verification|phone[-_/]?otp/.test(u) || (dom.mentionsPhone && !dom.mentionsEmailCode);
|
||
return phoneCtx ? 'phone_otp' : 'email_otp';
|
||
}
|
||
if (dom.pw > 0) return 'password';
|
||
if (dom.email > 0) return 'email_entry';
|
||
if (dom.name > 0 || dom.bday > 0) return 'about_you';
|
||
if (!dom.anyFillable && (dom.authorizeBtn || dom.consentText)) return 'consent';
|
||
if (!dom.anyFillable && dom.continueBtn) return 'interstitial';
|
||
return 'unknown';
|
||
}
|
||
|
||
// ==================== 跳过手机 + 采集会话（CK+AT）——新策略核心 ====================
|
||
// 在 add_phone 页尝试找「以后再说/跳过」入口并点一次；同时把手机页可点元素转储到 stderr
|
||
// （[CAP-DIAG] 原始行，便于确认到底有没有跳过入口）。找到并点了返回 true，否则 false。
|
||
async function trySkipPhone(page, say) {
|
||
try {
|
||
const diag = await page.evaluate(() => {
|
||
const text = (document.body && document.body.innerText || '').replace(/\s+/g, ' ').slice(0, 300);
|
||
const controls = [...document.querySelectorAll('a, button, [role="button"]')]
|
||
.filter((e) => e.offsetParent !== null).map((e) => (e.innerText || '').trim()).filter(Boolean).slice(0, 30);
|
||
return { url: location.href, text, controls };
|
||
});
|
||
process.stderr.write(`[CAP-DIAG] phonepage ${JSON.stringify(diag)}\n`);
|
||
} catch { /* ignore */ }
|
||
// 文案启发式：not now / maybe later / do this later / skip / remind me later …
|
||
const re = /not now|maybe later|i.?ll do (this|it) later|do (this|it) later|remind me|^skip$|skip for now/i;
|
||
const cand = page.locator('a, button, [role="button"]');
|
||
const n = await cand.count().catch(() => 0);
|
||
for (let i = 0; i < n; i++) {
|
||
const el = cand.nth(i);
|
||
try {
|
||
if (!(await el.isVisible())) continue;
|
||
const txt = ((await el.innerText().catch(() => '')) || '').trim();
|
||
if (txt && re.test(txt)) { say('info', '尝试跳过手机'); await el.click().catch(() => {}); return true; }
|
||
} catch { /* 试下一个 */ }
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// ==================== 登录后引导页 / 空白页兜底 ====================
|
||
// 「You're all set」引导页：黑色对勾 + 大标题 "You're all set" + 正文 "ChatGPT can make mistakes.
|
||
// Don't share sensitive info…" + 黑色 Continue 按钮。新号登录后常弹此页，不点 Continue 会一直被
|
||
// 弹回首页（实测导致进设置开 2FA 时始终被踢回 chatgpt.com/ 空转）。这里按可见文本健壮识别并点 Continue。
|
||
// 用「You're all set / Welcome」作引导页强信号（不能只用 "ChatGPT can make mistakes"——正常聊天页底部
|
||
// 也有这句，会误伤）。返回是否点了。
|
||
async function dismissOnboarding(page, say) {
|
||
const clicked = await page.evaluate(() => {
|
||
const txt = (document.body && document.body.innerText || '');
|
||
const isOnboard = /you'?re all set|welcome to chatgpt|准备就绪|全部设置完成|欢迎使用/i.test(txt);
|
||
if (!isOnboard) return '';
|
||
const re = /^(continue|okay,? let'?s go|get started|got it|done|next|继续|开始使用|知道了|完成)$/i;
|
||
const dlgs = [...document.querySelectorAll('[role="dialog"]')];
|
||
const scopes = dlgs.length ? dlgs : [document.body];
|
||
for (const sc of scopes) {
|
||
for (const b of sc.querySelectorAll('button, [role="button"], a')) {
|
||
const t = (b.innerText || b.getAttribute('aria-label') || '').trim();
|
||
if (t && re.test(t)) { b.click(); return t; }
|
||
}
|
||
}
|
||
return '';
|
||
}).catch(() => '');
|
||
if (clicked) { if (say) say('info', '关闭引导页'); await sleep(600); return true; }
|
||
return false;
|
||
}
|
||
// 空白/未加载兜底：页面几乎无正文且无任何可交互元素时，F5 刷新一次再继续检测（避免死等空白页）。
|
||
async function refreshIfBlank(page) {
|
||
const blank = await page.evaluate(() => {
|
||
const t = (document.body && document.body.innerText || '').trim();
|
||
const hasCtl = document.querySelector('button, input, textarea, [role="button"], a[href]');
|
||
return t.length < 5 && !hasCtl;
|
||
}).catch(() => false);
|
||
if (blank) { await page.reload({ waitUntil: 'domcontentloaded' }).catch(() => {}); await sleep(800); return true; }
|
||
return false;
|
||
}
|
||
|
||
// ==================== TOTP（用于开启并确认 2FA 认证器）====================
|
||
// base32 解码（RFC4648，忽略空格/分隔）。
|
||
function base32Decode(s) {
|
||
const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
|
||
const clean = String(s || '').toUpperCase().replace(/[^A-Z2-7]/g, '');
|
||
let bits = 0, value = 0; const out = [];
|
||
for (const c of clean) {
|
||
const idx = alphabet.indexOf(c);
|
||
if (idx < 0) continue;
|
||
value = (value << 5) | idx; bits += 5;
|
||
if (bits >= 8) { out.push((value >>> (bits - 8)) & 0xff); bits -= 8; }
|
||
}
|
||
return Buffer.from(out);
|
||
}
|
||
// 由 base32 密钥算当前 6 位 TOTP（HMAC-SHA1，30s 步长）——用于向 OpenAI 确认认证器已绑定。
|
||
function totpNow(secret, t = Date.now()) {
|
||
const key = base32Decode(secret);
|
||
let counter = Math.floor(t / 1000 / 30);
|
||
const buf = Buffer.alloc(8);
|
||
for (let i = 7; i >= 0; i--) { buf[i] = counter & 0xff; counter = Math.floor(counter / 256); }
|
||
const h = crypto.createHmac('sha1', key).update(buf).digest();
|
||
const off = h[h.length - 1] & 0x0f;
|
||
const bin = ((h[off] & 0x7f) << 24) | ((h[off + 1] & 0xff) << 16) | ((h[off + 2] & 0xff) << 8) | (h[off + 3] & 0xff);
|
||
return String(bin % 1000000).padStart(6, '0');
|
||
}
|
||
|
||
// 校验 2FA 是否真已开启：enroll 对话框（#enroll-totp-modal-title）应已关闭且无「验证码错误」提示；
|
||
// 认证器开关若可读到 aria-checked=true / 内部 checkbox.checked 更是铁证。
|
||
async function verify2faEnabled(page) {
|
||
await sleep(300); // 外层已按 1s 轮询，这里只需极短稳定
|
||
return await page.evaluate(() => {
|
||
const body = (document.body.innerText || '');
|
||
// enroll 对话框还在 + 有错误文案 → 明确失败（验证码不对）
|
||
if (document.querySelector('#enroll-totp-modal-title') && /incorrect|invalid|try again|wrong|didn'?t match/i.test(body)) return false;
|
||
const t = document.querySelector('[data-testid="mfa-authenticator-toggle"]');
|
||
if (t) {
|
||
if (t.getAttribute('aria-checked') === 'true') return true;
|
||
const inp = t.querySelector('input[type="checkbox"]');
|
||
if (inp && inp.checked) return true;
|
||
}
|
||
// 兜底：enroll 对话框已消失（点 Verify 成功后 OpenAI 会关闭它/进入备份码），且无错误文案。
|
||
return !document.querySelector('#enroll-totp-modal-title');
|
||
}).catch(() => false);
|
||
}
|
||
|
||
// 开启 TOTP 2FA 完整闭环并返回 base32 密钥（失败返回 ''，绝不影响主注册结果）。实测流程：
|
||
// chatgpt.com/#settings/Security → 点 mfa-authenticator-toggle → 跳 auth.openai.com/email-verification
|
||
// （邮箱验证码二次验证身份）→ 填码 Continue → 回设置弹窗 → 再点一次开关 → 弹出「Connect your
|
||
// authenticator app」对话框（QR 链接 otpauth://…?secret=<base32>，输入框 name=totp_otp，按钮 Verify）
|
||
// → 从 otpauth 链接解析 secret → 算当前 TOTP → 填入 → 点 Verify → 校验确已开启。
|
||
// 关键：一定走到「填码→提交→确认」，绝不「拿到 secret 就关」。整段 try/catch：2FA 失败不拖垮已拿的 AT/密码。
|
||
async function enableTotp2fa(context, page, email, otpBase, say) {
|
||
const TOGGLE = '[data-testid="mfa-authenticator-toggle"]';
|
||
try {
|
||
say('info', '开启2FA中');
|
||
// 关键：新号登录后停在「You're all set」引导页，不先关掉它，进 #settings 会被弹回首页 → 开关点了
|
||
// 也白点、页面空转到超时（实测就是这样）。先关引导页 + 空白页 F5 兜底，再进安全设置。
|
||
await dismissOnboarding(page, say);
|
||
await refreshIfBlank(page);
|
||
await page.goto('https://chatgpt.com/#settings/Security', { waitUntil: 'domcontentloaded' }).catch(() => {});
|
||
await settle(page);
|
||
await dismissOnboarding(page, say); // 进设置若又被引导页拦截，再关一次
|
||
// 提速：等开关出现从 20s 收到 12s；出现即继续（条件等待，不死等）。
|
||
try { await page.locator(TOGGLE).first().waitFor({ state: 'visible', timeout: 12000 }); } catch { /* 面板未出，下面循环兜底 */ }
|
||
// 基线设在点开关之前：只认此刻之后到达的「2FA 二次验证」邮件码，避开注册时的旧码。
|
||
const twoFaBaseline = Date.now();
|
||
// enroll 对话框检测：QR 可能是 otpauth 链接 / canvas / data:image，标题文案也可能变；用宽判据。
|
||
const detectEnroll = () => page.evaluate(() => {
|
||
if (document.querySelector('a[href^="otpauth://"]')) return true;
|
||
if (document.querySelector('#enroll-totp-modal-title, input[name="totp_otp"]')) return true;
|
||
const dlgs = [...document.querySelectorAll('[role="dialog"]')];
|
||
const top = dlgs[dlgs.length - 1];
|
||
if (top) {
|
||
const t = (top.innerText || '').toLowerCase();
|
||
if (/(authenticator app|scan (this |the )?qr|can'?t scan|trouble scanning|enter (this |the )?key|setup key|扫描|验证器|身份验证器)/.test(t)) return true;
|
||
if (top.querySelector('canvas, img[src^="data:image"], svg')) return true;
|
||
}
|
||
return false;
|
||
}).catch(() => false);
|
||
// 先点「Trouble scanning?」展开手动密钥（中英文健壮匹配；限最顶层对话框，避开设置面板里的 passkeys）。
|
||
const revealManualKey = () => page.evaluate(() => {
|
||
const r = /trouble scanning|can'?t scan|scan(ning)?\s*(issue|problem)|enter (this |the )?key manually|manual entry|扫描.*(问题|不了|失败)|无法扫描|遇到问题|手动(输入|录入|输入密钥)|输入密钥/i;
|
||
const dlgs = [...document.querySelectorAll('[role="dialog"]')];
|
||
const scope = dlgs[dlgs.length - 1] || document;
|
||
for (const n of scope.querySelectorAll('button, a, [role="button"], summary')) {
|
||
const t = (n.innerText || n.getAttribute('aria-label') || '');
|
||
if (t && r.test(t)) { n.click(); return; }
|
||
}
|
||
}).catch(() => {});
|
||
// 从 enroll 对话框抓 base32 secret。顺序很关键：
|
||
// ① 二维码 otpauth://…?secret=<base32> —— 权威来源，一次给出完整精确 secret；
|
||
// ② Trouble scanning 展开后的手动密钥文本 —— 必须按「4 位一组、空格/横线分隔」的形态严格捕获，
|
||
// 否则贪婪匹配会把 secret 和相邻大写文本连成一串（曾抓到 57 位废串导致 TOTP 算错、验证失败）；
|
||
// ③ 只读框/等宽块里独立成段的严格 base32。全部经 ok() 严格校验（≥24 位且含数字），排除姓名/FREE 误抓。
|
||
const extractSecret = () => page.evaluate(() => {
|
||
const norm = (s) => (s || '').replace(/[\s-]+/g, '').toUpperCase();
|
||
const ok = (s) => /^[A-Z2-7]{16,64}$/.test(s) && /[2-7]/.test(s);
|
||
const dlgs = [...document.querySelectorAll('[role="dialog"]')];
|
||
const scope = dlgs[dlgs.length - 1] || document.body;
|
||
// ① otpauth 链接（权威）
|
||
const a = scope.querySelector('a[href^="otpauth://"]') || document.querySelector('a[href^="otpauth://"]');
|
||
if (a) { try { const u = new URL(a.getAttribute('href')); const s = norm(u.searchParams.get('secret') || ''); if (ok(s)) return s; } catch { /* */ } }
|
||
const stext = scope.innerText || '';
|
||
// ② 手动密钥：严格「4 位一组×4~13 组」，避免连带相邻文本
|
||
const grouped = stext.match(/\b([A-Z2-7]{4}(?:[ -][A-Z2-7]{4}){3,12})\b/);
|
||
if (grouped) { const n = norm(grouped[1]); if (ok(n)) return n; }
|
||
// ②b 手动密钥：label 后紧跟的一整段连续 base32（无分组时）
|
||
const near = stext.match(/(?:secret|key|密钥|代码|manual entry|setup key)[^A-Za-z0-9]{0,24}([A-Z2-7]{16,64})\b/i);
|
||
if (near) { const n = norm(near[1]); if (ok(n)) return n; }
|
||
// ③ 只读框/等宽块
|
||
for (const el of scope.querySelectorAll('code, pre, input[readonly], [class*="secret" i], [class*="key" i], [class*="mono" i]')) {
|
||
const v = norm(el.value || el.innerText || ''); if (ok(v)) return v;
|
||
}
|
||
return '';
|
||
}).catch(() => '');
|
||
// 处理一次邮箱二次验证（step-up）：取码→填→Continue→回设置。可能在点开关后、也可能在打开
|
||
// enroll 对话框「那一刻」才触发（实测：对话框先闪现，随即整页跳 auth.openai.com/email-verification）。
|
||
const handleEmailVerify = async () => {
|
||
say('info', '2FA邮箱验证');
|
||
const code = await waitEmailOtp(otpBase, email, { baselineTs: twoFaBaseline, say });
|
||
if (!code) throw new Error('2FA邮箱码超时');
|
||
const box = await firstVisible(page, ['input[name="code"]', 'input[autocomplete="one-time-code"]', 'input[inputmode="numeric"]'], 6000);
|
||
if (box) { await box.fill(''); await box.type(code, { delay: 40 }); }
|
||
const cont = await firstVisible(page, ['button:has-text("Continue")', 'button[type="submit"]'], 3000);
|
||
if (cont) await cont.click().catch(() => {});
|
||
// 提速：条件等待——等到「离开 email-verification 页」（跳回 action=enable/设置）即继续，最多 8s，不死等 3s。
|
||
await page.waitForURL((u) => !/email-verification/.test(String(u)), { timeout: 8000 }).catch(() => {});
|
||
await settle(page);
|
||
};
|
||
|
||
// 统一状态循环：email-verification 可能在任意时刻出现（点开关后 / 交互 enroll 对话框时）。
|
||
// 每轮按「当前页」判定：验证页→做邮箱二次验证并重开开关；enroll 对话框→展开抓密钥；
|
||
// 都没有→隔几秒补点一次开关。直到抓到 secret 或超总预算。避免旧两段式在「对话框→中途跳验证」时空跑。
|
||
await page.locator(TOGGLE).first().click().catch(() => {});
|
||
let secret = '';
|
||
let emailDone = false;
|
||
let lastToggle = Date.now();
|
||
let lastTrace = 0;
|
||
const deadline = Date.now() + 210000; // 总预算 3.5 分钟（含等邮箱码）
|
||
while (!secret && Date.now() < deadline) {
|
||
const url = page.url();
|
||
if (Date.now() - lastTrace > 5000) { lastTrace = Date.now(); const en = await detectEnroll(); diag2fa(`loop url=${url.slice(0, 55)} enroll=${en}`); }
|
||
if (/email-verification/.test(url)) {
|
||
await handleEmailVerify();
|
||
emailDone = true;
|
||
// 关键：邮箱二次验证后 OpenAI 会跳回 /?action=enable&factor=totp#settings/Security，SPA 据此
|
||
// 「自动打开」enroll 对话框——此时绝不能再点开关（再点等于取消这次开启、把刚弹的对话框关掉，
|
||
// 实测就是这样导致对话框始终 dlgs=0）。这里只给 SPA 一点时间，交给下面 detectEnroll 捕获。
|
||
lastToggle = Date.now(); // 抑制补点：给深链自动开对话框留出时间
|
||
await sleep(2500);
|
||
continue;
|
||
}
|
||
if (await detectEnroll()) {
|
||
await revealManualKey();
|
||
await sleep(1200);
|
||
secret = await extractSecret();
|
||
if (secret) break;
|
||
// 对话框在但没抓到：可能点开关那刻正要 step-up 跳验证页，下一轮由 url 分支处理。
|
||
await sleep(1200);
|
||
continue;
|
||
}
|
||
// 无对话框：分三种情形处理——
|
||
const onEnableLink = /action=enable/.test(url);
|
||
const onSettings = /#settings\/security/i.test(url) || /\/settings/i.test(url);
|
||
if (onEnableLink) {
|
||
// ① action=enable 深链：SPA 会自动开对话框，别乱点开关（再点=取消开启）；超 12s 没开才补点一次。
|
||
if (Date.now() - lastToggle > 12000) { await page.locator(TOGGLE).first().click().catch(() => {}); lastToggle = Date.now(); }
|
||
} else if (!onSettings) {
|
||
// ② 不在设置页（多为登录后被弹回 chatgpt.com/ 首页 / You're all set 引导页 / 空白页）：
|
||
// 别再点不存在的开关空转。先关引导页 → 空白页 F5 兜底 → 重新进设置页点开关。隔 3.5s 一次。
|
||
if (Date.now() - lastToggle > 3500) {
|
||
await dismissOnboarding(page, say);
|
||
await refreshIfBlank(page);
|
||
await page.goto('https://chatgpt.com/#settings/Security', { waitUntil: 'domcontentloaded' }).catch(() => {});
|
||
await settle(page);
|
||
await page.locator(TOGGLE).first().click().catch(() => {});
|
||
lastToggle = Date.now();
|
||
}
|
||
} else {
|
||
// ③ 在设置页但没弹对话框：隔 5s 补点一次开关触发开启。
|
||
if (Date.now() - lastToggle > 5000) { await page.locator(TOGGLE).first().click().catch(() => {}); lastToggle = Date.now(); }
|
||
}
|
||
await sleep(700);
|
||
}
|
||
diag2fa(`loopEnd url=${page.url().slice(0, 60)} emailDone=${emailDone} secret=${secret ? secret.slice(0, 4) + '…len' + secret.length : 'none'}`);
|
||
if (!secret || !/^[A-Z2-7]{24,64}$/.test(secret)) {
|
||
const diag = await page.evaluate(() => {
|
||
const dlgs = [...document.querySelectorAll('[role="dialog"]')];
|
||
const top = dlgs[dlgs.length - 1];
|
||
return { url: location.href, dlgs: dlgs.length, hasOtpauth: !!document.querySelector('a[href^="otpauth://"]'), topText: top ? (top.innerText || '').replace(/\s+/g, ' ').slice(0, 200) : '' };
|
||
}).catch(() => ({}));
|
||
diag2fa(`noSecret ${JSON.stringify(diag)}`);
|
||
throw new Error('未取到2FA密钥（enroll 对话框未稳定出现）');
|
||
}
|
||
diag2fa(`secret=${secret.slice(0, 4)}… len=${secret.length}`);
|
||
// 填 6 位 TOTP → Verify。刚好跨 30s 边界会失效，这里紧接着算+填+提交，窗口足够。
|
||
const inp = await firstVisible(page, ['input[name="totp_otp"]', 'input[placeholder*="6-digit" i]', 'input[inputmode="numeric"]', 'input[maxlength="6"]'], 6000);
|
||
if (!inp) throw new Error('未找到验证码输入框');
|
||
await inp.fill(''); await inp.type(totpNow(secret), { delay: 60 });
|
||
const verify = await firstVisible(page, ['button:has-text("Verify")', 'button:has-text("Enable")', 'button[type="submit"]'], 3000);
|
||
if (!verify) throw new Error('未找到 Verify 按钮');
|
||
await verify.click().catch(() => {});
|
||
// 提速：把固定 4s 等待改成条件轮询——最多 8s，一旦确认已开启立即继续，不死等。
|
||
let enabled = false;
|
||
for (let i = 0; i < 8 && !enabled; i++) { await sleep(1000); enabled = await verify2faEnabled(page); }
|
||
if (!enabled) throw new Error('提交验证码后未确认已开启');
|
||
// 关掉可能出现的备份码/成功后续弹窗，避免影响后续采集。
|
||
await page.evaluate(() => {
|
||
for (const b of document.querySelectorAll('button')) { if (/^(done|close|got it|continue)$/i.test((b.innerText || '').trim())) { b.click(); return; } }
|
||
}).catch(() => {});
|
||
say('ok', '2FA已开启');
|
||
return secret;
|
||
} catch (e) {
|
||
diag2fa(`fail ${String(e).slice(0, 160)}`);
|
||
say('warn', '2FA开启失败');
|
||
return '';
|
||
}
|
||
}
|
||
|
||
// 采集「会话 cookie(CK) + 网页 AT」：
|
||
// CK：导出 context 全量 cookie（含 auth.openai.com / chatgpt.com 的 session）；
|
||
// AT：访问 chatgpt.com 建立会话后，fetch /api/auth/session 取 accessToken（若被 onboarding 拦回则拿不到）。
|
||
// 全程把关键信号写 [CAP-DIAG] 原始行，便于研判「手机前能否拿到可用会话/AT」。
|
||
async function captureWebSession(context, page, say) {
|
||
const out = { cookies: [], webAccessToken: '', chatgptUrl: '', sessionStatus: 0, sessionHead: '' };
|
||
try { out.cookies = await context.cookies(); } catch { /* ignore */ }
|
||
try {
|
||
const names = out.cookies.map((c) => `${c.domain}:${c.name}`);
|
||
process.stderr.write(`[CAP-DIAG] cookies n=${out.cookies.length} names=${JSON.stringify(names.slice(0, 40))}\n`);
|
||
} catch { /* ignore */ }
|
||
say('info', '采集会话中');
|
||
// 访问 chatgpt.com：看是否放行（拿到会话）还是被重定向回 onboarding/手机页
|
||
try {
|
||
await page.goto('https://chatgpt.com/', { waitUntil: 'domcontentloaded', timeout: 45000 });
|
||
await sleep(1000); // 提速：会话 cookie 已就绪，只需短暂稳定即可 fetch /api/auth/session（3500→1000）
|
||
} catch (e) { process.stderr.write(`[CAP-DIAG] goto chatgpt err ${String(e).slice(0, 140)}\n`); }
|
||
try { out.chatgptUrl = page.url(); } catch { /* ignore */ }
|
||
process.stderr.write(`[CAP-DIAG] chatgpt landing=${out.chatgptUrl}\n`);
|
||
// 取网页 AT：/api/auth/session（登录态则返回 {accessToken,...}）。
|
||
// 关键：在浏览器内解析「完整 body」再取 accessToken——之前把 body 截断到 2000 字符后再 JSON.parse，
|
||
// 因 session 响应很大（WARNING_BANNER/user 在前、accessToken 在后）被截断成非法 JSON，导致 AT 一直取空。
|
||
try {
|
||
const r = await page.evaluate(async () => {
|
||
try {
|
||
const res = await fetch('/api/auth/session', { credentials: 'include', headers: { accept: 'application/json' } });
|
||
const t = await res.text();
|
||
let accessToken = '';
|
||
let accountId = '';
|
||
try {
|
||
const j = JSON.parse(t);
|
||
if (j && j.accessToken) accessToken = j.accessToken;
|
||
accountId = (j && j.user && (j.user.id || j.user.chatgpt_account_id)) || '';
|
||
} catch { /* 非 JSON */ }
|
||
return { status: res.status, url: res.url, head: t.slice(0, 160), accessToken, accountId };
|
||
} catch (e) { return { status: -1, url: '', head: 'ERR ' + String(e), accessToken: '', accountId: '' }; }
|
||
});
|
||
out.sessionStatus = r.status; out.sessionHead = r.head || '';
|
||
if (r.accessToken) out.webAccessToken = r.accessToken;
|
||
if (r.accountId) out.accountId = r.accountId;
|
||
process.stderr.write(`[CAP-DIAG] session status=${r.status} url=${r.url} at=${r.accessToken ? r.accessToken.slice(0, 12) + '…len' + r.accessToken.length : 'NONE'}\n`);
|
||
} catch (e) { process.stderr.write(`[CAP-DIAG] session err ${String(e).slice(0, 140)}\n`); }
|
||
// 导航后重新导出 cookie（可能新增 chatgpt.com 域的 session cookie）
|
||
try { out.cookies = await context.cookies(); } catch { /* ignore */ }
|
||
return out;
|
||
}
|
||
|
||
// 归一化保存的 cookie 以喂给 context.addCookies：只保留必要字段，sameSite 归一到合法枚举，
|
||
// 过滤掉缺 domain/name 的脏数据（否则 addCookies 会整批抛错）。
|
||
function sanitizeCookies(list) {
|
||
const okSame = new Set(['Strict', 'Lax', 'None']);
|
||
const out = [];
|
||
for (const c of list || []) {
|
||
if (!c || !c.name || !c.domain) continue;
|
||
const ck = {
|
||
name: String(c.name),
|
||
value: String(c.value == null ? '' : c.value),
|
||
domain: String(c.domain),
|
||
path: c.path || '/',
|
||
httpOnly: !!c.httpOnly,
|
||
secure: !!c.secure,
|
||
};
|
||
if (typeof c.expires === 'number' && c.expires > 0) ck.expires = c.expires;
|
||
let ss = c.sameSite;
|
||
if (ss === 'no_restriction' || ss === 'None') ss = 'None';
|
||
else if (ss === 'lax' || ss === 'Lax') ss = 'Lax';
|
||
else if (ss === 'strict' || ss === 'Strict') ss = 'Strict';
|
||
ck.sameSite = okSame.has(ss) ? ss : 'Lax';
|
||
out.push(ck);
|
||
}
|
||
return out;
|
||
}
|
||
|
||
// 是否已存在 chatgpt.com 的 next-auth 会话 cookie（登录成功标志；匿名态没有）。
|
||
// 兼容分块 cookie（__Secure-next-auth.session-token / .0 / .1），且要求 value 非空。
|
||
async function hasNextAuthSession(context) {
|
||
try {
|
||
const cs = await context.cookies();
|
||
return cs.some((c) => /(^|\.)?next-auth\.session-token(\.\d+)?$/i.test(c.name || '')
|
||
&& String(c.value || '').length > 10);
|
||
} catch { return false; }
|
||
}
|
||
|
||
// 打开 chatgpt.com 的登录/注册面板并露出邮箱输入框。
|
||
// chatgpt.com 落地页有两种变体：①右侧直接是「Email address + Continue」；②聊天页只有
|
||
// 「Log in / Sign up for free」按钮，需先点一下才弹出邮箱输入。让 chatgpt.com 自己发起
|
||
// next-auth signin（state/CSRF 由它维护，比手拼 authorize URL 稳）。返回是否已露出邮箱框。
|
||
async function openAuthPanel(page) {
|
||
const hasEmail = async () => {
|
||
try {
|
||
const el = await firstVisible(page, [
|
||
'input[type="email"]', 'input[name="email"]', 'input#email-input',
|
||
'input[autocomplete="username"]', 'input[placeholder*="email" i]',
|
||
], 600);
|
||
return !!el;
|
||
} catch { return false; }
|
||
};
|
||
const re = /sign ?up|log ?in|create.*account|get started|注册|登录/i;
|
||
for (let attempt = 0; attempt < 4; attempt++) {
|
||
if (await hasEmail()) return true;
|
||
// 找可点的「注册/登录」入口（优先注册），点开面板。
|
||
const cand = page.locator('a, button, [role="button"]');
|
||
const n = await cand.count().catch(() => 0);
|
||
let clicked = false;
|
||
for (const preferSignup of [true, false]) {
|
||
for (let i = 0; i < n; i++) {
|
||
const el = cand.nth(i);
|
||
try {
|
||
if (!(await el.isVisible())) continue;
|
||
const txt = ((await el.innerText().catch(() => '')) || '').trim();
|
||
if (!txt || txt.length > 30 || !re.test(txt)) continue;
|
||
if (preferSignup && !/sign ?up|get started|注册/i.test(txt)) continue;
|
||
await el.click().catch(() => {});
|
||
clicked = true;
|
||
break;
|
||
} catch { /* 试下一个 */ }
|
||
}
|
||
if (clicked) break;
|
||
}
|
||
// 提速：点开后用「条件等待」替代固定 2.5s——邮箱框出现 / 跳到 auth.openai.com 任一满足即返回。
|
||
const deadline = Date.now() + 3500;
|
||
while (Date.now() < deadline) {
|
||
if (await hasEmail()) return true;
|
||
try { if (/auth\.openai\.com/.test(page.url())) return true; } catch { /* ignore */ }
|
||
await sleep(250);
|
||
}
|
||
}
|
||
return await hasEmail();
|
||
}
|
||
|
||
// 按「可见 label 文本」健壮定位并填写字段（about-you 变体多、裸 input 无 name/placeholder 常见）。
|
||
// 依次尝试：1) getByLabel(正则)；2) placeholder/aria-label 选择器；3) 传入的兜底选择器；
|
||
// 4) 就近法（找含 label 文案的元素 → for 关联或容器内最近 input）。填完读回 value 非空才算成功。
|
||
async function fillByLabel(page, labelTexts, value, extraSelectors = []) {
|
||
const tryLoc = async (loc) => {
|
||
try {
|
||
if (!(await loc.count())) return false;
|
||
if (!(await loc.isVisible().catch(() => false))) return false;
|
||
await loc.fill('').catch(() => {});
|
||
await loc.type(String(value), { delay: 30 });
|
||
const v = (await loc.inputValue().catch(() => '')) || '';
|
||
return v.trim() !== '';
|
||
} catch { return false; }
|
||
};
|
||
// 1) getByLabel
|
||
for (const lt of labelTexts) {
|
||
try {
|
||
if (await tryLoc(page.getByLabel(new RegExp(lt, 'i')).first())) return true;
|
||
} catch { /* ignore */ }
|
||
}
|
||
// 2) placeholder / aria-label
|
||
const sels = [];
|
||
for (const lt of labelTexts) sels.push(`input[placeholder*="${lt}" i]`, `input[aria-label*="${lt}" i]`);
|
||
sels.push(...extraSelectors);
|
||
for (const s of sels) {
|
||
if (await tryLoc(page.locator(s).first())) return true;
|
||
}
|
||
// 3) 就近法：在页面内按 label 文案找到关联 input，用 elementHandle 填
|
||
try {
|
||
const el = await page.evaluateHandle((texts) => {
|
||
const lc = texts.map((t) => t.toLowerCase());
|
||
const match = (t) => { t = (t || '').trim().toLowerCase(); return t && lc.some((k) => t === k || t.startsWith(k)); };
|
||
for (const lab of document.querySelectorAll('label, span, div, p')) {
|
||
if (!match(lab.textContent)) continue;
|
||
const forId = lab.getAttribute && lab.getAttribute('for');
|
||
if (forId) { const e = document.getElementById(forId); if (e && e.tagName === 'INPUT') return e; }
|
||
let p = lab;
|
||
for (let d = 0; d < 3 && p; d++, p = p.parentElement) {
|
||
const inp = p.querySelector && p.querySelector('input');
|
||
if (inp && inp.offsetParent !== null) return inp;
|
||
}
|
||
}
|
||
return null;
|
||
}, labelTexts);
|
||
const handle = el && el.asElement && el.asElement();
|
||
if (handle && await handle.isVisible().catch(() => false)) {
|
||
await handle.fill('').catch(() => {});
|
||
await handle.type(String(value), { delay: 30 }).catch(() => {});
|
||
const v = (await handle.inputValue().catch(() => '')) || '';
|
||
if (v.trim() !== '') return true;
|
||
}
|
||
} catch { /* ignore */ }
|
||
return false;
|
||
}
|
||
|
||
// ==================== 邮箱验证码：从 Flask /api/reg/inbox 轮询「新鲜」验证码 ====================
|
||
// 复刻协议模式 waitEmailOtp 的核心：只接受 baseline 之后到达、且像 OpenAI verification 的码，
|
||
// 优先 subject 含 "verification"（score 高）的那封，避免误用 login code。
|
||
function scoreOtp(m) {
|
||
const from = ((m && m.from_addr) || '').toLowerCase();
|
||
const subj = ((m && m.subject) || '').toLowerCase();
|
||
const isOpenAi = /openai|chatgpt/.test(from) || /openai|chatgpt/.test(subj);
|
||
if (!isOpenAi) return 0;
|
||
if (/verification code/.test(subj)) return 4;
|
||
if (/verification/.test(subj)) return 3;
|
||
// 2FA 二次验证/登录场景，OpenAI 邮件主题可能是 "login code"/"security code"/"your code"，
|
||
// 之前给 2 分被 verif(>=3) 与 generic(===1) 两个筛子都漏掉 → 永远取不到码。提到 3 分纳入正选。
|
||
if (/login code|security code|your .*code|one-?time|passcode/.test(subj)) return 3;
|
||
if (/\bcode\b/.test(subj)) return 1;
|
||
return 1;
|
||
}
|
||
async function waitEmailOtp(otpBase, email, { timeoutMs = 180000, intervalMs = 2500, baselineTs = 0, sinceSkewMs = 90000, say } = {}) {
|
||
const start = Date.now();
|
||
const threshold = baselineTs ? baselineTs - sinceSkewMs : 0;
|
||
let attempt = 0;
|
||
let fallback = null;
|
||
while (Date.now() - start < timeoutMs) {
|
||
attempt++;
|
||
try {
|
||
const res = await fetch(`${otpBase}/api/reg/inbox?email=${encodeURIComponent(email)}`);
|
||
const data = await res.json().catch(() => ({}));
|
||
const cands = [];
|
||
for (const m of (data.messages || [])) {
|
||
const ts = Date.parse(m.received_at || '') || 0;
|
||
const fresh = !threshold || ts >= threshold;
|
||
const code = m.extracted_code || extractCode(`${m.subject || ''} ${m.body || ''}`);
|
||
if (!code || !fresh) continue;
|
||
cands.push({ code, ts, score: scoreOtp(m) });
|
||
}
|
||
const verif = cands.filter((c) => c.score >= 3).sort((a, b) => (b.score - a.score) || (b.ts - a.ts))[0];
|
||
if (verif) { say && say('ok', '已收到验证码'); return verif.code; }
|
||
const generic = cands.filter((c) => c.score === 1).sort((a, b) => b.ts - a.ts)[0];
|
||
if (generic && !fallback) fallback = generic;
|
||
say && say('info', '等待验证码');
|
||
} catch { /* 单次失败继续轮询 */ }
|
||
await sleep(intervalMs);
|
||
}
|
||
if (fallback) { say && say('warn', '使用兜底验证码'); return fallback.code; }
|
||
return null;
|
||
}
|
||
|
||
// 在 OTP 输入区填入验证码：兼容单框（input[name=code]）与分段 6 框（逐位输入）。
|
||
// known：上游若已通过启发式定位到验证码输入框，传进来做最后兜底，避免 OpenAI 改版后
|
||
// 特定选择器失配导致「明明在验证码页却填不进去」。
|
||
async function fillOtp(page, code, known = null) {
|
||
const single = await firstVisible(page, [
|
||
'input[name="code"]',
|
||
'input[autocomplete="one-time-code"]',
|
||
'input[inputmode="numeric"]',
|
||
'input[name="otp"]',
|
||
], 2000);
|
||
if (single) {
|
||
await single.fill('');
|
||
await single.type(code, { delay: 60 });
|
||
return true;
|
||
}
|
||
// 分段输入框：找一组 input，逐位敲
|
||
const segs = page.locator('input[maxlength="1"]');
|
||
const n = await segs.count().catch(() => 0);
|
||
if (n >= code.length) {
|
||
for (let i = 0; i < code.length; i++) {
|
||
await segs.nth(i).type(code[i], { delay: 60 }).catch(() => {});
|
||
}
|
||
return true;
|
||
}
|
||
// 兜底：用上游传入的已定位框（启发式命中的那个可见输入）。
|
||
if (known) {
|
||
try {
|
||
await known.fill('');
|
||
await known.type(code, { delay: 60 });
|
||
return true;
|
||
} catch { /* ignore */ }
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 在手机页把「国家选择器」切到号码所属国家（iso2）。兼容三类控件：
|
||
// 1) 原生 <select>（option 值可能是 iso2 / 国码 / 含国家名）；
|
||
// 2) intl-tel-input（点旗标按钮展开列表，选 data-country-code=iso2 的项）；
|
||
// 3) 通用 combobox（aria-haspopup 按钮 + 列表项）。
|
||
// 成功返回 true（此后只需填「本国号」）；失败返回 false（回退：直接填「+完整E.164」让控件自识别）。
|
||
async function selectPhoneCountry(page, iso2) {
|
||
if (!iso2) return false;
|
||
// 1) 原生 select：尝试按 value/label 选中
|
||
try {
|
||
const sel = page.locator('select').first();
|
||
if (await sel.count() && await sel.isVisible().catch(() => false)) {
|
||
for (const v of [iso2, iso2.toUpperCase()]) {
|
||
try { await sel.selectOption(v, { timeout: 800 }); return true; } catch { /* 试下一个 */ }
|
||
}
|
||
}
|
||
} catch { /* ignore */ }
|
||
// 2/3) 旗标 / combobox 按钮 → 展开 → 选对应国家项
|
||
const flag = await firstVisible(page, [
|
||
'.iti__selected-flag', '.iti__selected-country', 'button.iti__selected-country',
|
||
'[class*="selected-flag"]', '[class*="country-selector"]', 'button[aria-haspopup="listbox"]',
|
||
], 1200);
|
||
if (flag) {
|
||
await flag.click().catch(() => {});
|
||
await sleep(400);
|
||
const item = await firstVisible(page, [
|
||
`.iti__country[data-country-code="${iso2}"]`, `li[data-country-code="${iso2}"]`,
|
||
`[data-country-code="${iso2}"]`, `li[data-country="${iso2}"]`, `[role="option"][data-country-code="${iso2}"]`,
|
||
], 1200);
|
||
if (item) { await item.click().catch(() => {}); await sleep(300); return true; }
|
||
await page.keyboard.press('Escape').catch(() => {});
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// ==================== 手机验证（浏览器 UI + 接码平台，best-effort） ====================
|
||
async function verifyPhoneInBrowser(page, sms, say) {
|
||
const MODS = { smscode, smsbower, herosms };
|
||
const LABELS = { smscode: 'smscode.gg', smsbower: 'smsbower.app', herosms: 'hero-sms.com' };
|
||
const provider = (sms && MODS[sms.provider]) ? sms.provider : 'smscode';
|
||
const mod = MODS[provider];
|
||
const cfg = (sms && sms[provider]) || {};
|
||
if (!cfg.apiKey) throw new Error('需要手机验证但未配置接码 API Key');
|
||
say('info', '需要手机验证');
|
||
// 多国候选：与协议模式一致，逐个国家换号重试
|
||
const cand = Array.isArray(cfg.countryCandidates) && cfg.countryCandidates.length
|
||
? cfg.countryCandidates.map((c) => (c && typeof c === 'object' ? c : { id: c })) : null;
|
||
const MAX = cand ? cand.length : Math.max(1, Number(sms.maxAttempts) || 3);
|
||
const perTimeout = Math.max(Number(sms.pollTimeout) || 0, 120000);
|
||
let lastErr = null;
|
||
for (let attempt = 1; attempt <= MAX; attempt++) {
|
||
let orderId = null;
|
||
const acfg = cand ? { ...cfg, country: cand[attempt - 1].id, countryId: cand[attempt - 1].id } : cfg;
|
||
try {
|
||
say('info', '获取手机号中');
|
||
const acq = await mod.acquireNumber(acfg, { log: () => {} });
|
||
orderId = acq.orderId;
|
||
const digits = String(acq.phone || '').replace(/[^\d]/g, '');
|
||
// 号码所属国家：优先用本次请求的 smsbower 国家 id 映射，其次按号码前缀反推国码。
|
||
const info = SMS_COUNTRY[acfg.country] || SMS_COUNTRY[String(acfg.country)] || null;
|
||
const { national } = splitDial(digits, info ? info.dial : '');
|
||
const iso2 = info ? info.iso2 : '';
|
||
const e164 = `+${digits}`;
|
||
|
||
const tel = await firstVisible(page, [
|
||
'input[type="tel"]', 'input[name="phone"]', 'input[name="phone_number"]', 'input[autocomplete="tel"]',
|
||
], 3000);
|
||
if (!tel) throw new Error('未找到手机号输入框');
|
||
|
||
// 关键：把页面上的国家选到号码所属国家（否则默认停在美国 +1，号码与国码对不上）。
|
||
const picked = await selectPhoneCountry(page, iso2);
|
||
if (picked) say('info', `已选国家 ${(iso2 || '').toUpperCase()}`);
|
||
// 控件是否单独展示国码（separate dial code）——是则只填本国号。
|
||
const separateDial = await page.evaluate(
|
||
() => !!document.querySelector('.iti__selected-dial-code, [class*="selected-dial-code"]'),
|
||
).catch(() => false);
|
||
|
||
await tel.click().catch(() => {});
|
||
await tel.fill('');
|
||
if (picked || separateDial) {
|
||
// 已选对国家 / 控件自带国码：只填本国号（无国码），与所选国家拼成正确号码。
|
||
await tel.type(national || digits, { delay: 40 });
|
||
} else {
|
||
// 没选到国家：填「+完整E.164」，靠控件对「+」前缀自动识别国家（与 HTTP 模式 formatE164 一致）。
|
||
await tel.type(e164, { delay: 40 });
|
||
}
|
||
await tel.press('Enter').catch(() => {});
|
||
await sleep(1500);
|
||
say('info', '等待验证码');
|
||
const otp = await mod.pollOtp(acfg, orderId, { timeoutMs: perTimeout, log: () => {} });
|
||
const ok = await fillOtp(page, otp.code);
|
||
if (!ok) throw new Error('未找到短信验证码输入框');
|
||
await page.keyboard.press('Enter').catch(() => {});
|
||
await mod.finishOrder(acfg, orderId).catch(() => {});
|
||
say('ok', '手机验证通过');
|
||
return true;
|
||
} catch (e) {
|
||
lastErr = e;
|
||
const msg = String((e && e.message) || e);
|
||
if (/NO_BALANCE|余额/.test(msg)) { say('warn', '接码余额不足'); throw e; }
|
||
say('warn', '手机验证失败');
|
||
try { await mod.cancelOrder(acfg, orderId, { log: () => {} }); } catch { /* ignore */ }
|
||
}
|
||
}
|
||
throw new Error(`手机验证失败：${lastErr ? lastErr.message : '未知'}`);
|
||
}
|
||
|
||
// ==================== 主流程 ====================
|
||
(async () => {
|
||
let email = '';
|
||
let browser = null;
|
||
let context = null;
|
||
let registered = false; // 是否已越过「建号」步（用于让上游把邮箱标 burned）
|
||
try {
|
||
const input = JSON.parse((await readStdin()) || '{}');
|
||
email = input.email || '';
|
||
const settings = input.settings || {};
|
||
const proxy = input.proxy || null;
|
||
const otpBase = String(input.otpBase || 'http://127.0.0.1:5088').replace(/\/$/, '');
|
||
const headless = input.headless !== false; // 默认无头
|
||
const licenseKey = String(input.licenseKey || settings.cloakLicenseKey || '').trim();
|
||
// 固定/确定性密码（settings.regPassword，缺省用内置强口令）：见 reg_password.mjs 说明。
|
||
const password = resolveRegPassword(input, settings);
|
||
const sms = settings.sms || {};
|
||
// 新策略：注册阶段不做手机验证——走到 add_phone 时不接码，改为采集「会话 cookie(CK)+网页 AT」入库，
|
||
// 手机/RT 由后续「批量绑手机拿RT」单独做。opt-in（默认 false，保持老行为不变）。
|
||
// 用 let：bindPhone 模式在「拿到会话→转 codex 授权」时会把它切回 false（此步必须真接码）。
|
||
let skipPhone = input.skipPhone === true;
|
||
// 网页客户端注册（走 chatgpt.com 普通 signup，一般不强制手机）：opt-in，默认沿用 codex 入口。
|
||
// 用 let：bindPhone 模式先用网页登录建立会话（webClient=true），拿到会话后切 false 转 codex 授权拿 RT。
|
||
let webClient = input.webClient === true;
|
||
// 批量绑手机拿RT（针对无密码网页号）：先用「保存的 CK 恢复会话」，失效则「邮箱验证码重登」，
|
||
// 建立 chatgpt.com 登录态后，再走 codex 授权（app_EMoam…）触发手机验证 → 拿独立 codex RT。
|
||
const bindPhone = input.bindPhone === true;
|
||
const restoreCookies = Array.isArray(input.cookies) ? input.cookies : [];
|
||
if (bindPhone) { webClient = true; skipPhone = false; } // 绑机：先网页登录，后 codex 必须接码
|
||
// 网页注册拿到登录态后是否开启 TOTP 2FA（默认开；绑机模式不开）。
|
||
const enable2fa = input.enable2fa !== false && !bindPhone;
|
||
if (!email) throw new Error('缺少邮箱');
|
||
|
||
emitLog('info', bindPhone ? '开始绑机' : '开始注册', email);
|
||
const proxyStr = proxyToString(proxy);
|
||
emitLog('info', `浏览器启动（${headless ? '无头' : '有头'}${proxyStr ? ' · 代理' : ''}）`, email);
|
||
|
||
// 每号一套独立指纹：CloakBrowser 用 --fingerprint=<每次随机seed> 已在二进制层随机 canvas/webgl/
|
||
// 音频/字体等；这里再用 fingerprint.js 让「语言/时区」也逐号变化（经二进制 flag 设置、彼此自洽、
|
||
// 不走可检测的 CDP 模拟）。不覆盖 UA/sec-ch-ua——那会与二进制真实 146 头不一致反成强特征。
|
||
const fp = generateFingerprint();
|
||
process.stderr.write(`[FP-DIAG] locale=${fp.language} tz=${fp.timezone} screen=${fp.screenStr} ua=${fp.userAgent.slice(0, 40)}\n`);
|
||
|
||
// 启动 CloakBrowser：launchContext 每次都是「全新隐身上下文 + 独立临时 profile」（chromium.launch()
|
||
// 分配一次性 user-data-dir，close 即弃），因此逐号天然隔离、无 cookie/localStorage 残留。
|
||
// --disable-quic：经 HTTP 代理时 QUIC/HTTP3(UDP) 无法隧道，实测不加此 flag 连 auth.openai.com 会
|
||
// ERR_CONNECTION_REFUSED；关掉 QUIC 强制走 TCP 后各 OpenAI 域名均可正常访问。
|
||
context = await launchContext({
|
||
headless,
|
||
proxy: proxyStr,
|
||
licenseKey: licenseKey || undefined,
|
||
locale: fp.language, // 逐号变化的英文区语言（en-US/en-GB/en-CA）
|
||
timezone: fp.timezone, // 与语言自洽的时区
|
||
humanize: true,
|
||
args: ['--disable-quic'],
|
||
});
|
||
browser = context.browser();
|
||
// 兜底再清一遍会话态：新上下文本为空，但异常复用/残留时这一步保证「干净新注册」——用户实测
|
||
// 报「直接弹已登录账号」，显式清 cookie 后即便底层被复用也不会带上一号登录态。
|
||
try { await context.clearCookies(); } catch { /* ignore */ }
|
||
const page = await context.newPage();
|
||
page.setDefaultTimeout(45000);
|
||
// 有头模式：把窗口顶到前台，避免开在其它窗口后面让用户以为「没开浏览器」。
|
||
if (!headless) { try { await page.bringToFront(); } catch { /* ignore */ } }
|
||
|
||
// 拦截 redirect_uri：注册收尾会 302 到 localhost:1455/auth/callback?code=…，
|
||
// 这里 fulfill 一个空 200 并把 code 记下来（浏览器无需真的连到本地 1455）。
|
||
let authCode = null;
|
||
await context.route('http://localhost:1455/**', async (route) => {
|
||
try {
|
||
const u = new URL(route.request().url());
|
||
if (u.searchParams.get('code')) authCode = u.searchParams.get('code');
|
||
} catch { /* ignore */ }
|
||
try { await route.fulfill({ status: 200, contentType: 'text/html', body: 'ok' }); } catch { /* ignore */ }
|
||
});
|
||
|
||
// say 提前定义：网页入口块（openAuthPanel/日志）会用到，避免 TDZ「Cannot access 'say' before init」。
|
||
const say = (level, msg) => emitLog(level, msg, email);
|
||
|
||
// 测试/复用入口：mode2fa —— 用已存 CK 恢复登录态后，仅跑「开启 TOTP 2FA」完整闭环并回吐密钥。
|
||
// 供验证 2FA 闭环（填码→提交→确认）用，也可日后给「已登录账号补开 2FA」复用。
|
||
if (input.mode2fa === true) {
|
||
if (restoreCookies.length) { try { await context.addCookies(sanitizeCookies(restoreCookies)); } catch { /* */ } }
|
||
await page.goto('https://chatgpt.com/', { waitUntil: 'domcontentloaded' }).catch(() => {});
|
||
await sleep(3000);
|
||
const sec = await enableTotp2fa(context, page, email, otpBase, say);
|
||
try { await browser.close(); } catch { /* ignore */ }
|
||
realStdoutWrite(JSON.stringify({ ok: !!sec, twoFactorSecret: sec || '' }));
|
||
return;
|
||
}
|
||
|
||
// 从 codex 客户端的 /oauth/authorize 起步，并 screen_hint=signup 直达注册 UI。
|
||
const { verifier, challenge } = generatePkce();
|
||
const state = crypto.randomBytes(32).toString('base64url');
|
||
const authorizeUrl = `${OAUTH_ISSUER}/oauth/authorize?` + new URLSearchParams({
|
||
response_type: 'code', client_id: OAUTH_CLIENT_ID, redirect_uri: OAUTH_REDIRECT_URI,
|
||
scope: OAUTH_SCOPE, code_challenge: challenge, code_challenge_method: 'S256', state,
|
||
screen_hint: 'signup', prompt: 'login',
|
||
}).toString();
|
||
// codex 授权（用于 bindPhone：已在浏览器里建立 chatgpt.com 登录态后，对已存在账号发起 codex 授权，
|
||
// 触发手机验证并换取独立 codex RT）。不带 screen_hint=signup——是对既有账号授权而非建号；
|
||
// 关键：不带 prompt=login——否则会强制邮箱重新验证(步进验证)，而我们要复用已恢复的会话直达授权/手机。
|
||
const codexAuthorizeUrl = `${OAUTH_ISSUER}/oauth/authorize?` + new URLSearchParams({
|
||
response_type: 'code', client_id: OAUTH_CLIENT_ID, redirect_uri: OAUTH_REDIRECT_URI,
|
||
scope: OAUTH_SCOPE, code_challenge: challenge, code_challenge_method: 'S256', state,
|
||
}).toString();
|
||
|
||
if (bindPhone) {
|
||
// 绑机阶段一：恢复 chatgpt.com 登录态。优先用保存的 CK；失效则走网页邮箱验证码重登。
|
||
if (restoreCookies.length) {
|
||
try { await context.addCookies(sanitizeCookies(restoreCookies)); say('info', '恢复会话中'); }
|
||
catch (e) { process.stderr.write(`[BIND-DIAG] addCookies err ${String(e).slice(0, 120)}\n`); }
|
||
}
|
||
await page.goto('https://chatgpt.com/', { waitUntil: 'domcontentloaded' }).catch(() => {});
|
||
await sleep(1200);
|
||
if (await hasNextAuthSession(context)) {
|
||
say('ok', '会话已恢复');
|
||
} else {
|
||
// CK 失效/为空：露出邮箱面板，交给状态机走「邮箱→验证码(→密码)」登录，拿到会话后再转 codex。
|
||
say('info', 'CK失效改邮箱登录');
|
||
await firstVisible(page, [
|
||
'input[type="email"]', 'input[placeholder*="email" i]',
|
||
'button:has-text("Sign up")', 'button:has-text("Log in")', 'button:text-is("Continue")',
|
||
], 6000).catch(() => null);
|
||
await openAuthPanel(page).catch(() => {});
|
||
}
|
||
} else if (webClient) {
|
||
// 网页注册入口：直接开 chatgpt.com 落地页。现代 chatgpt.com 右侧就是「Sign up or log in」面板
|
||
//（Email address 输入 + Continue，属 login_or_signup 统一入口）——新邮箱填进去点 Continue 即进注册。
|
||
// 由 chatgpt.com 自己发起 next-auth signin（POST 带 CSRF），state/CSRF 全程它维护，最稳；
|
||
// 手拼 authorize URL / 直连 signin GET 都会得到「会话已结束 / auth/error」。
|
||
// 后续交给状态机：email_entry(填邮箱→Continue) → 密码 → 邮箱验证码 → about-you → 回落 chatgpt.com 登录态。
|
||
say('info', '进入网页注册');
|
||
await page.goto('https://chatgpt.com/', { waitUntil: 'domcontentloaded' }).catch(() => {});
|
||
// 提速：不再固定等 4s——等落地页出现可交互入口（邮箱框 / 登录·注册按钮）后再开面板，最多 ~6s。
|
||
await firstVisible(page, [
|
||
'input[type="email"]', 'input[placeholder*="email" i]',
|
||
'button:has-text("Sign up")', 'button:has-text("Log in")', 'button:text-is("Continue")',
|
||
], 6000).catch(() => null);
|
||
// 露出邮箱输入框（两种落地变体都兼容）；露不出来也继续，交给状态机兜底判定。
|
||
await openAuthPanel(page).catch(() => {});
|
||
} else {
|
||
await page.goto(authorizeUrl, { waitUntil: 'domcontentloaded' }).catch(() => {});
|
||
}
|
||
|
||
const otpBaselineTs = Date.now();
|
||
|
||
// 按「当前页面真实特征」判定的状态机：每轮 detectPage 读 URL+DOM，classifyPage 判定当前步，
|
||
// 再精确处理对应步骤。授权只在「无任何可填输入 + 授权语境」时点，非授权页绝不点 Continue，
|
||
// 从根本上杜绝「在验证码/密码页上空点 Continue 跳过验证」的历史 bug。
|
||
let phoneDone = false; // 手机验证是否已在本次流程里处理过
|
||
let pwSubmitted = false; // 是否已提交过密码（建号或登录）——用于日志用词
|
||
let otpFilled = false; // 邮箱验证码是否已成功填过一次（用于识别「提交后过渡页」）
|
||
let skipTried = false; // skipPhone 模式下「找跳过入口」是否已尝试过（只试一次）
|
||
let phonePending = false; // skipPhone 模式：已到手机页但按策略不验、改为采集 CK+AT 入库
|
||
let capturedCookies = null; // 采集到的会话 cookie（CK）
|
||
let webAccessToken = ''; // 采集到的网页 access token（AT）
|
||
let capturedAccountId = ''; // 采集到的 chatgpt account id（可选）
|
||
let twoFactorSecret = ''; // 开启 TOTP 2FA 后拿到的 base32 密钥（失败留空）
|
||
let dumped = false; // 未知页面只转储一次 DOM 诊断，避免刷屏
|
||
let lastSig = ''; // 上一轮「类型|URL」签名，判断是否卡在同一页
|
||
let sameCount = 0;
|
||
// 提速：轮询间隔 350ms→250ms 更跟手；步数上限相应提到 180 以保住整体墙钟预算（邮箱验证码的长等
|
||
// 在 email_otp 分支内阻塞、不占这里的步数）。卡住判定的 sameCount 阈值保持不变，仍靠墙钟容忍。
|
||
for (let step = 0; step < 180 && !authCode; step++) {
|
||
await sleep(250);
|
||
if (authCode) break;
|
||
|
||
const snap = await detectPage(page);
|
||
if (authCode) break;
|
||
const type = classifyPage(snap);
|
||
const sig = `${type}|${snap.url}`;
|
||
if (sig === lastSig) sameCount++; else { sameCount = 0; lastSig = sig; }
|
||
|
||
// 硬信号：密码错误（多为「此邮箱曾用别的密码注册」）→ 直接失败，别再空转。
|
||
if (snap.dom && snap.dom.wrongCred) {
|
||
throw new Error('邮箱或密码不正确（此邮箱可能曾用别的密码注册）');
|
||
}
|
||
|
||
// 网页客户端终止条件：出现 chatgpt.com 的 next-auth 会话 cookie 即代表「已登录」。
|
||
// 关键：网页 signup 是「邮箱验证码即登录」的无密码流（实测无密码步、也不强制手机），
|
||
// 所以不能用 pwSubmitted 当门槛；只认 __Secure-next-auth.session-token（登录后才有、匿名态没有），
|
||
// 每轮都查（不导航），一出现就采集 CK+AT 并结束。
|
||
if (webClient && (await hasNextAuthSession(context))) {
|
||
if (bindPhone) {
|
||
// 绑机：已建立 chatgpt.com 登录态 → 转 codex 授权（同一浏览器会话，auth.openai.com 已有 SSO），
|
||
// 触发手机验证 → 拿独立 codex RT。切 webClient=false 让终止逻辑改用 codex 的 authCode。
|
||
say('ok', '会话就绪转授权');
|
||
webClient = false;
|
||
skipPhone = false; // 此步必须真接码
|
||
phoneDone = false;
|
||
await page.goto(codexAuthorizeUrl, { waitUntil: 'domcontentloaded' }).catch(() => {});
|
||
await settle(page);
|
||
continue;
|
||
}
|
||
const cap = await captureWebSession(context, page, say);
|
||
capturedCookies = cap.cookies;
|
||
webAccessToken = cap.webAccessToken;
|
||
capturedAccountId = cap.accountId || '';
|
||
// 拿到登录态后开启 TOTP 2FA 并保存密钥（默认开启，可传 enable2fa=false 关闭）。失败不影响入库。
|
||
if (enable2fa) {
|
||
twoFactorSecret = await enableTotp2fa(context, page, email, otpBase, say);
|
||
// 开 2FA 后会话 cookie 可能刷新，重采一次 CK，保证落库的是最新会话。
|
||
try { capturedCookies = await context.cookies(); } catch { /* ignore */ }
|
||
}
|
||
phonePending = true; // 网页号暂无 codex RT：CK+AT(+2FA) 入库，SUB 列显示否
|
||
break;
|
||
}
|
||
|
||
if (type === 'email_entry') {
|
||
const el = await firstVisible(page, [
|
||
'input[name="email"]', 'input#email-input', 'input[type="email"]', 'input[autocomplete="username"]',
|
||
'input[placeholder*="email" i]',
|
||
], 1500);
|
||
if (el) {
|
||
say('info', '提交邮箱');
|
||
await el.fill('');
|
||
await el.type(email, { delay: 40 });
|
||
await submitStep(page);
|
||
await settle(page);
|
||
await waitLeaveType(page, 'email_entry');
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (type === 'password') {
|
||
const pw = await firstVisible(page, [
|
||
'input[type="password"]', 'input[name="password"]', 'input[name="new-password"]',
|
||
], 1500);
|
||
if (pw) {
|
||
// 建号与「已注册邮箱重进」的登录都用同一固定密码；已注册邮箱也能凭此登录拿状态。
|
||
say('info', pwSubmitted ? '重新登录中' : '创建账号中');
|
||
// 单页表单可能同时要邮箱：为空则补填，避免只填密码提交失败。
|
||
const em = await firstVisible(page, ['input[type="email"]', 'input[name="email"]'], 400);
|
||
if (em) {
|
||
const v = await em.inputValue().catch(() => '');
|
||
if (!v) { await em.fill(''); await em.type(email, { delay: 30 }); }
|
||
}
|
||
await pw.fill('');
|
||
await pw.type(password, { delay: 40 });
|
||
await submitStep(page);
|
||
registered = true;
|
||
pwSubmitted = true;
|
||
say('info', '发送验证码');
|
||
await settle(page);
|
||
await waitLeaveType(page, 'password');
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (type === 'email_otp') {
|
||
const otpBox = (await firstVisible(page, [
|
||
'input[name="code"]', 'input[autocomplete="one-time-code"]', 'input[inputmode="numeric"]',
|
||
'input[name="otp"]', 'input[maxlength="1"]', 'input[maxlength="6"]',
|
||
], 1200)) || await findGenericOtpBox(page);
|
||
// 已填过码后又回到验证码页：多为「刚回车、正在校验/跳转」的同一过渡页（框被禁用/仍带旧值）。
|
||
// 此时别重复填（会因框只读而报「未能填入」），等它跳走即可；长时间不走才判校验失败。
|
||
if (otpFilled) {
|
||
if (!otpBox) { await settle(page); continue; }
|
||
const busy = await page.evaluate(() => {
|
||
const skip = ['password', 'email', 'tel', 'hidden', 'checkbox', 'radio', 'submit', 'button'];
|
||
return [...document.querySelectorAll('input')].filter((i) => i.offsetParent !== null).some(
|
||
(i) => (i.readOnly || i.disabled || String(i.value || '').trim() !== '')
|
||
&& !skip.includes((i.getAttribute('type') || 'text').toLowerCase()),
|
||
);
|
||
}).catch(() => false);
|
||
if (busy) { await settle(page); continue; }
|
||
if (sameCount >= 8) throw new Error('邮箱验证码校验未通过');
|
||
}
|
||
say('info', '等待验证码');
|
||
const code = await waitEmailOtp(otpBase, email, { baselineTs: otpBaselineTs, say });
|
||
if (!code) throw new Error('邮箱验证码等待超时');
|
||
const ok = await fillOtp(page, code, otpBox);
|
||
if (!ok) throw new Error('未能填入邮箱验证码');
|
||
await page.keyboard.press('Enter').catch(() => {});
|
||
otpFilled = true;
|
||
say('ok', '邮箱验证通过');
|
||
// 关键：提交后主动等「离开验证码页」再继续，避免在过渡页二次误入验证码分支。
|
||
await waitLeaveType(page, 'email_otp');
|
||
continue;
|
||
}
|
||
|
||
if (type === 'phone') {
|
||
if (skipPhone) {
|
||
// 新策略：不接码。先试「以后再说/跳过」入口；能跳过就让状态机继续（可能直达 about-you/授权）。
|
||
if (!skipTried) {
|
||
skipTried = true;
|
||
const skipped = await trySkipPhone(page, say);
|
||
if (skipped) { await settle(page); continue; }
|
||
}
|
||
// 无跳过入口 / 跳过后仍回手机页：采集 CK+AT，结束状态机去入库（手机待绑）。
|
||
say('info', '跳过手机验证');
|
||
const cap = await captureWebSession(context, page, say);
|
||
capturedCookies = cap.cookies;
|
||
webAccessToken = cap.webAccessToken;
|
||
capturedAccountId = cap.accountId || '';
|
||
phonePending = true;
|
||
break;
|
||
}
|
||
if (!phoneDone) {
|
||
await verifyPhoneInBrowser(page, sms, say);
|
||
phoneDone = true;
|
||
await settle(page);
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (type === 'about_you') {
|
||
say('info', '完善资料中');
|
||
// 判定变体：优先看是否有「生日框」→ 变体B（名/姓+生日）；否则若有「Age(整数)」→ 变体A（Full name+Age）。
|
||
// 提速：两个探测合并为单次 page.evaluate，减少一次往返。
|
||
const { hasBday, hasAge } = await page.evaluate(() => {
|
||
const vis = (e) => e && e.offsetParent !== null;
|
||
const hasBday = [...document.querySelectorAll(
|
||
'input[type="date"], input[name="birthdate"], input[name="bday"], input[placeholder*="birth" i]',
|
||
)].some(vis);
|
||
let hasAge = [...document.querySelectorAll(
|
||
'input[name="age" i], input[placeholder*="age" i], input[aria-label*="age" i]',
|
||
)].some(vis);
|
||
if (!hasAge) {
|
||
for (const l of document.querySelectorAll('label, span, div, p')) {
|
||
const t = (l.textContent || '').trim().toLowerCase();
|
||
if (t === 'age' || t.startsWith('age')) {
|
||
let p = l;
|
||
for (let d = 0; d < 3 && p; d++, p = p.parentElement) { if (p.querySelector && p.querySelector('input')) { hasAge = true; break; } }
|
||
}
|
||
if (hasAge) break;
|
||
}
|
||
}
|
||
return { hasBday, hasAge };
|
||
}).catch(() => ({ hasBday: false, hasAge: false }));
|
||
|
||
let okFilled = false;
|
||
if (hasBday) {
|
||
// 变体B：名/姓（拿不到则退回单个 Full name）+ 生日(YYYY-MM-DD)
|
||
const first = FIRST[crypto.randomInt(0, FIRST.length)];
|
||
const last = LAST[crypto.randomInt(0, LAST.length)];
|
||
const fOk = await fillByLabel(page, ['first name', 'first', 'given'], first,
|
||
['input[name="firstName" i]', 'input[autocomplete="given-name"]']);
|
||
const lOk = await fillByLabel(page, ['last name', 'last', 'family', 'surname'], last,
|
||
['input[name="lastName" i]', 'input[autocomplete="family-name"]']);
|
||
let nameOk = fOk && lOk;
|
||
if (!nameOk) {
|
||
nameOk = await fillByLabel(page, ['full name', 'name'], `${first} ${last}`,
|
||
['input[name="name"]', 'input#name', 'input[autocomplete="name"]']);
|
||
}
|
||
const bOk = await fillByLabel(page, ['date of birth', 'birthdate', 'birth', 'dob'], randomAdultBirthdate(),
|
||
['input[type="date"]', 'input[name="birthdate"]', 'input[name="bday"]']);
|
||
okFilled = nameOk && bOk;
|
||
} else {
|
||
// 变体A（截图这种）：Full name + Age(整数 18~48)
|
||
const fullName = randomFullName();
|
||
const age = String(18 + crypto.randomInt(0, 31));
|
||
const nOk = await fillByLabel(page, ['full name', 'name'], fullName,
|
||
['input[name="name"]', 'input#name', 'input[autocomplete="name"]']);
|
||
const aOk = await fillByLabel(page, ['age'], age,
|
||
['input[name="age"]', 'input[type="number"]', 'input[inputmode="numeric"]']);
|
||
okFilled = nOk && aOk;
|
||
}
|
||
|
||
if (!okFilled) {
|
||
// 没填成功绝不点「Finish creating account」：转储诊断，稍等重试；久卡才判失败。
|
||
await dumpDiag(page);
|
||
if (sameCount >= 7) throw new Error('补资料填写失败（字段未识别）');
|
||
await settle(page);
|
||
continue;
|
||
}
|
||
say('ok', '资料已填写');
|
||
// 点「Finish creating account」/ Continue 提交
|
||
const fin = await firstVisible(page, [
|
||
'button:has-text("Finish creating account")', 'button:text-is("Continue")',
|
||
'button:text-is("Next")', 'button[type="submit"]',
|
||
], 1500);
|
||
if (fin) { await fin.click().catch(() => {}); } else { await submitStep(page); }
|
||
await settle(page);
|
||
await waitLeaveType(page, 'about_you');
|
||
continue;
|
||
}
|
||
|
||
if (type === 'choose_account') {
|
||
// 账号选择页：点「含本邮箱的账号磁贴」，避开「Log in to another account / Create account」。
|
||
// 用 Playwright 真实点击（React SPA 需真实指针事件；page.evaluate 里的 DOM .click() 常不触发导航）。
|
||
say('info', '选择账号中');
|
||
let clicked = false;
|
||
try {
|
||
const tile = page.locator('button, [role="button"], a').filter({ hasText: email }).first();
|
||
if (await tile.isVisible()) { await tile.click(); clicked = true; }
|
||
} catch { /* ignore */ }
|
||
if (!clicked) {
|
||
const b = await firstVisible(page, ['button:has-text("Select account")', `button:has-text("${email}")`], 1500);
|
||
if (b) { await b.click().catch(() => {}); clicked = true; }
|
||
}
|
||
await settle(page);
|
||
await waitLeaveType(page, 'choose_account', 12000);
|
||
continue;
|
||
}
|
||
|
||
if (type === 'consent' || type === 'callback') {
|
||
// 真·授权页（无可填输入 + 授权按钮/授权语境）才点授权。
|
||
say('info', '获取授权中');
|
||
const btn = await firstVisible(page, [
|
||
'button:text-is("Authorize")', 'button:text-is("Allow")', 'button:text-is("Agree")',
|
||
'button:text-is("Continue")', 'button[type="submit"]',
|
||
], 1200);
|
||
if (btn) { await btn.click().catch(() => {}); await settle(page); }
|
||
continue;
|
||
}
|
||
|
||
if (type === 'interstitial') {
|
||
// 「You're all set」引导页也常被归到过渡页：优先按引导页处理（点其 Continue）。命中即继续。
|
||
if (await dismissOnboarding(page, say)) { await settle(page); continue; }
|
||
// 无可填输入、只有普通 Continue、又无授权语境：多为过渡/加载页。稳定几轮后点一次
|
||
// （此时确无输入可填，点它安全、不会跳过输入步）；限制点击轮次，避免对死按钮狂点。
|
||
if (sameCount >= 3 && sameCount <= 8) {
|
||
const btn = await firstVisible(page, ['button:text-is("Continue")', 'button[type="submit"]'], 1000);
|
||
if (btn) { await btn.click().catch(() => {}); await settle(page); }
|
||
} else {
|
||
await sleep(300);
|
||
}
|
||
continue;
|
||
}
|
||
|
||
// loading / unknown / phone_otp：等待页面稳定；未知页卡住先做「引导页 + 空白页 F5」兜底
|
||
// （新号登录后被弹回首页/空白页会长期归为 unknown），再转储诊断；久卡才中止（绝不盲进授权）。
|
||
if (type === 'unknown' && sameCount >= 2) {
|
||
if (await dismissOnboarding(page, say)) { await settle(page); continue; }
|
||
if (await refreshIfBlank(page)) { await settle(page); continue; }
|
||
}
|
||
if (!dumped && type === 'unknown' && sameCount >= 3) { dumped = true; await dumpDiag(page); }
|
||
if (type === 'unknown' && sameCount >= 14) {
|
||
await dumpDiag(page).catch(() => {});
|
||
throw new Error('停留在未知页面，已中止（未进入授权）');
|
||
}
|
||
await sleep(300);
|
||
}
|
||
|
||
// 网页模式兜底：循环结束但可能已在 chatgpt.com 建立登录态（session cookie 已就绪），
|
||
// 补采一次 CK+AT 并置 phonePending，走下面统一出口入库，避免误落到 codex 的 authCode 分支。
|
||
if (webClient && !phonePending && (await hasNextAuthSession(context))) {
|
||
const cap = await captureWebSession(context, page, say);
|
||
capturedCookies = cap.cookies;
|
||
webAccessToken = cap.webAccessToken;
|
||
capturedAccountId = cap.accountId || '';
|
||
phonePending = true;
|
||
}
|
||
if (webClient && !phonePending) {
|
||
throw new Error('网页注册未建立登录态（未拿到 chatgpt.com 会话）');
|
||
}
|
||
|
||
// 新策略：跳过手机 → 不换 RT，直接带「CK(cookies)+AT」入库（手机待绑，SUB=否）。
|
||
if (phonePending) {
|
||
// 仅在「连 cookie 都没采到」时补采一次。注意：网页 AT 在「未绑手机」状态被 OpenAI 挡住
|
||
//（/api/auth/session 返回 200 但为匿名、无 accessToken），所以不能因 AT 为空就重复采集，
|
||
// 否则每次都白跑一次 chatgpt.com 导航。AT 留待后续「批量绑手机拿RT」用 CK 恢复会话后再取。
|
||
if (!capturedCookies || !capturedCookies.length) {
|
||
const cap = await captureWebSession(context, page, say);
|
||
capturedCookies = (capturedCookies && capturedCookies.length) ? capturedCookies : cap.cookies;
|
||
webAccessToken = webAccessToken || cap.webAccessToken;
|
||
capturedAccountId = capturedAccountId || cap.accountId || '';
|
||
}
|
||
const gotAt = !!(webAccessToken && webAccessToken.length > 20);
|
||
const gotCk = Array.isArray(capturedCookies) && capturedCookies.length > 0;
|
||
say(gotAt || gotCk ? 'ok' : 'warn', gotAt ? '已拿会话与AT' : (gotCk ? '已拿会话' : '会话采集不全'));
|
||
const result = {
|
||
ok: true,
|
||
phonePending: true, // 标记：网页号暂无 codex RT（供后端标 SUB=否）
|
||
refreshToken: '', // 无 codex RT
|
||
accessToken: webAccessToken || '',
|
||
webAccessToken: webAccessToken || '',
|
||
webRefreshToken: '', // 网页 RT：next-auth 不向客户端暴露 refresh_token，无法自助获取（见汇报）
|
||
twoFactorSecret: twoFactorSecret || '', // 2FA base32 密钥（开启成功才有）
|
||
cookies: capturedCookies || [], // CK：序列化会话 cookie
|
||
chatgptAccountId: capturedAccountId || '',
|
||
clientId: OAUTH_CLIENT_ID,
|
||
password,
|
||
subOk: false,
|
||
};
|
||
try { await browser.close(); } catch { /* ignore */ }
|
||
realStdoutWrite(JSON.stringify(result));
|
||
return;
|
||
}
|
||
|
||
if (!authCode) {
|
||
// 兜底：若已完成登录态但未触发跳转，主动再访问一次 authorize，让服务端直接给 code。
|
||
// bindPhone 用 codex 授权地址（对既有账号），其它用注册 authorize。
|
||
await page.goto(bindPhone ? codexAuthorizeUrl : authorizeUrl, { waitUntil: 'domcontentloaded' }).catch(() => {});
|
||
for (let i = 0; i < 8 && !authCode; i++) await sleep(700);
|
||
}
|
||
if (!authCode) throw new Error('未能取得 authorization code（注册 UI 未走到授权跳转）');
|
||
say('ok', '获取授权成功');
|
||
|
||
// 用同一 context（同 cookie、同代理）POST /oauth/token 换 refresh_token。
|
||
say('info', '获取令牌中');
|
||
const tokResp = await context.request.post(`${OAUTH_ISSUER}/oauth/token`, {
|
||
form: {
|
||
grant_type: 'authorization_code',
|
||
code: authCode,
|
||
redirect_uri: OAUTH_REDIRECT_URI,
|
||
client_id: OAUTH_CLIENT_ID,
|
||
code_verifier: verifier,
|
||
},
|
||
});
|
||
if (!tokResp.ok()) {
|
||
const body = await tokResp.text().catch(() => '');
|
||
throw new Error(`换取 token 失败：HTTP ${tokResp.status()} ${body.slice(0, 160)}`);
|
||
}
|
||
const tok = await tokResp.json().catch(() => ({}));
|
||
if (!tok.refresh_token) throw new Error('token 响应缺少 refresh_token');
|
||
|
||
say('ok', '账号登录成功');
|
||
// 浏览器模式不再单独跑第二阶段 SUB（拿不到就 SUB=否，与需求一致）。
|
||
const result = {
|
||
ok: true,
|
||
refreshToken: tok.refresh_token,
|
||
accessToken: tok.access_token || '',
|
||
idToken: tok.id_token || '',
|
||
clientId: OAUTH_CLIENT_ID,
|
||
password,
|
||
subOk: false,
|
||
};
|
||
try { await browser.close(); } catch { /* ignore */ }
|
||
realStdoutWrite(JSON.stringify(result));
|
||
} catch (e) {
|
||
const msg = (e && e.message) || String(e);
|
||
emitLog('error', msg, email);
|
||
try { if (browser) await browser.close(); } catch { /* ignore */ }
|
||
const banned = /deleted or deactivated|deactivat|账号已停用/i.test(msg);
|
||
realStdoutWrite(JSON.stringify({ ok: false, banned, registered, error: msg }));
|
||
}
|
||
})();
|