specific-ai-cli 0.0.0-stage → 0.1.1

package/dist/platforms/bilibili/web/ddddocr.js

@@ -0,0 +1,342 @@
+import { readFileSync } from 'node:fs';
+import { SpecificAIError } from '../../../core/errors.js';
+import { decodeImage as decodeRgba, loadCv } from '../../../core/image.js';
+const f = Math.fround;
+// ---------------------------------------------------------------- 图片
+/** 解码题图为 RGB（alpha 丢弃，与 cv2.imdecode 的 IMREAD_COLOR 一致）。 */
+export async function decodeImage(bytes) {
+    const png = await decodeRgba(bytes);
+    if (!png)
+        throw new SpecificAIError('RISK_CONTROL', '极验题图无法解码', { detail: { kind: 'captcha' } });
+    const data = new Uint8Array(png.width * png.height * 3);
+    for (let i = 0, j = 0; j < data.length; i += 4, j += 3)
+        data.set(png.rgba.subarray(i, i + 3), j);
+    return { width: png.width, height: png.height, data };
+}
+/** PIL 的 `Image.crop((x1, y1, x2, y2))`：越界部分填 0。 */
+export function crop(im, x1, y1, x2, y2) {
+    const w = Math.max(0, x2 - x1);
+    const h = Math.max(0, y2 - y1);
+    const data = new Uint8Array(w * h * 3);
+    for (let y = 0; y < h; y++) {
+        const sy = y + y1;
+        if (sy < 0 || sy >= im.height)
+            continue;
+        for (let x = 0; x < w; x++) {
+            const sx = x + x1;
+            if (sx < 0 || sx >= im.width)
+                continue;
+            const s = (sy * im.width + sx) * 3;
+            data.set(im.data.subarray(s, s + 3), (y * w + x) * 3);
+        }
+    }
+    return { width: w, height: h, data };
+}
+// ---------------------------------------------------------------- Pillow：LANCZOS 缩放与转灰度
+const PRECISION_BITS = 32 - 8 - 2;
+function sinc(x) {
+    if (x === 0)
+        return 1;
+    x *= Math.PI;
+    return Math.sin(x) / x;
+}
+const lanczos = (x) => (-3 <= x && x < 3 ? sinc(x) * sinc(x / 3) : 0);
+/** Resample.c 的 precompute_coeffs + normalize_coeffs_8bpc。 */
+function coeffs(inSize, outSize) {
+    const scale = inSize / outSize;
+    const filterscale = scale < 1 ? 1 : scale;
+    const support = 3 * filterscale;
+    const ksize = Math.ceil(support) * 2 + 1;
+    const bounds = new Int32Array(outSize * 2);
+    const kk = new Int32Array(outSize * ksize);
+    const k = new Float64Array(ksize);
+    const inv = 1 / filterscale;
+    for (let xx = 0; xx < outSize; xx++) {
+        const center = (xx + 0.5) * scale;
+        let ww = 0;
+        const xmin = Math.max(0, Math.trunc(center - support + 0.5));
+        const xmax = Math.min(inSize, Math.trunc(center + support + 0.5)) - xmin;
+        k.fill(0);
+        for (let x = 0; x < xmax; x++) {
+            const w = lanczos((x + xmin - center + 0.5) * inv);
+            k[x] = w;
+            ww += w;
+        }
+        if (ww !== 0)
+            for (let x = 0; x < xmax; x++)
+                k[x] /= ww;
+        for (let x = 0; x < ksize; x++) {
+            const v = k[x] * (1 << PRECISION_BITS);
+            kk[xx * ksize + x] = Math.trunc(v < 0 ? v - 0.5 : v + 0.5);
+        }
+        bounds[xx * 2] = xmin;
+        bounds[xx * 2 + 1] = xmax;
+    }
+    return { ksize, bounds, kk };
+}
+const clip8 = (ss) => Math.min(255, Math.max(0, Math.floor(ss / (1 << PRECISION_BITS))));
+/** `Image.resize((w, h), Image.LANCZOS)`（ImagingResampleInner：先水平、后垂直，水平只处理垂直方向用得到的行）。 */
+export function resizeLanczos(im, width, height) {
+    if (width === im.width && height === im.height)
+        return { width, height, data: im.data.slice() };
+    const needH = width !== im.width;
+    const needV = height !== im.height;
+    const vert = coeffs(im.height, height);
+    let src = im;
+    if (needH) {
+        const first = vert.bounds[0];
+        const last = vert.bounds[height * 2 - 2] + vert.bounds[height * 2 - 1];
+        for (let i = 0; i < height; i++)
+            vert.bounds[i * 2] -= first;
+        const { ksize, bounds, kk } = coeffs(im.width, width);
+        const rows = last - first;
+        const out = new Uint8Array(width * rows * 3);
+        for (let yy = 0; yy < rows; yy++) {
+            const line = (yy + first) * im.width * 3;
+            for (let xx = 0; xx < width; xx++) {
+                const xmin = bounds[xx * 2];
+                const xmax = bounds[xx * 2 + 1];
+                const k = xx * ksize;
+                let s0 = 1 << (PRECISION_BITS - 1);
+                let s1 = s0;
+                let s2 = s0;
+                for (let x = 0; x < xmax; x++) {
+                    const p = line + (x + xmin) * 3;
+                    const c = kk[k + x];
+                    s0 += im.data[p] * c;
+                    s1 += im.data[p + 1] * c;
+                    s2 += im.data[p + 2] * c;
+                }
+                const o = (yy * width + xx) * 3;
+                out[o] = clip8(s0);
+                out[o + 1] = clip8(s1);
+                out[o + 2] = clip8(s2);
+            }
+        }
+        src = { width, height: rows, data: out };
+    }
+    if (!needV)
+        return src;
+    const { ksize, bounds, kk } = vert;
+    const out = new Uint8Array(src.width * height * 3);
+    for (let yy = 0; yy < height; yy++) {
+        const ymin = bounds[yy * 2];
+        const ymax = bounds[yy * 2 + 1];
+        const k = yy * ksize;
+        for (let xx = 0; xx < src.width; xx++) {
+            let s0 = 1 << (PRECISION_BITS - 1);
+            let s1 = s0;
+            let s2 = s0;
+            for (let y = 0; y < ymax; y++) {
+                const p = ((y + ymin) * src.width + xx) * 3;
+                const c = kk[k + y];
+                s0 += src.data[p] * c;
+                s1 += src.data[p + 1] * c;
+                s2 += src.data[p + 2] * c;
+            }
+            const o = (yy * src.width + xx) * 3;
+            out[o] = clip8(s0);
+            out[o + 1] = clip8(s1);
+            out[o + 2] = clip8(s2);
+        }
+    }
+    return { width: src.width, height, data: out };
+}
+/** `convert('L')`：ITU-R 601-2，Pillow 的定点写法 L24。 */
+export function toGray(im) {
+    const out = new Uint8Array(im.width * im.height);
+    for (let i = 0; i < out.length; i++) {
+        const p = i * 3;
+        out[i] = (im.data[p] * 19595 + im.data[p + 1] * 38470 + im.data[p + 2] * 7471 + 0x8000) >> 16;
+    }
+    return out;
+}
+/** 识别模型的输入：等比缩放到高 64 后转灰度（OCREngine._preprocess_image）。 */
+export function ocrInput(im) {
+    const width = Math.trunc(im.width * (64 / im.height));
+    return { width, height: 64, gray: toGray(resizeLanczos(im, width, 64)) };
+}
+let modelPaths = null;
+function models() {
+    modelPaths ??= import('specific-ai-assets-ocr').then((m) => m.models, () => {
+        modelPaths = null;
+        throw new SpecificAIError('ERROR', '没有安装 OCR 模型包 specific-ai-assets-ocr', { hint: '重新安装 specific-ai-cli；specific-ai doctor 可以检查' });
+    });
+    return modelPaths;
+}
+const sessions = new Map();
+async function session(which) {
+    let s = sessions.get(which);
+    if (!s) {
+        s = (async () => {
+            const path = (await models())[which];
+            let bytes;
+            try {
+                bytes = readFileSync(path);
+            }
+            catch {
+                throw new SpecificAIError('ERROR', `OCR 模型文件缺失：${path}`, { hint: '重新安装 specific-ai-cli（specific-ai-assets-ocr）' });
+            }
+            const ort = await import('onnxruntime-web');
+            ort.env.wasm.numThreads = 1;
+            // 识别模型声明的输出形状不对，每次推理都会警告；与上游 set_default_logger_severity(3) 一样只报错误
+            ort.env.logLevel = 'error';
+            return ort.InferenceSession.create(bytes, { logSeverityLevel: 3 });
+        })();
+        s.catch(() => sessions.delete(which));
+        sessions.set(which, s);
+    }
+    return s;
+}
+let charsetCache = null;
+async function charset() {
+    charsetCache ??= models().then((m) => JSON.parse(readFileSync(m.charset, 'utf8')));
+    return charsetCache;
+}
+async function run(which, data, dims) {
+    const ort = await import('onnxruntime-web');
+    const sess = await session(which);
+    const out = await sess.run({ [sess.inputNames[0]]: new ort.Tensor('float32', data, dims) });
+    const t = out[sess.outputNames[0]];
+    return { data: t.data, dims: t.dims };
+}
+// ---------------------------------------------------------------- 检测
+const DET_SIZE = 416;
+/** DetectionEngine.preproc：BGR 等比缩放贴到 114 灰底的 416×416（HWC uint8）。 */
+export async function detInput(im) {
+    const cv = await loadCv();
+    const r = Math.min(DET_SIZE / im.height, DET_SIZE / im.width);
+    const w = Math.trunc(im.width * r);
+    const h = Math.trunc(im.height * r);
+    const bgr = new Uint8Array(im.data.length);
+    for (let i = 0; i < bgr.length; i += 3) {
+        bgr[i] = im.data[i + 2];
+        bgr[i + 1] = im.data[i + 1];
+        bgr[i + 2] = im.data[i];
+    }
+    const src = new cv.Mat(im.height, im.width, cv.CV_8UC3);
+    const dst = new cv.Mat();
+    let resized;
+    try {
+        src.data.set(bgr);
+        cv.resize(src, dst, new cv.Size(w, h), 0, 0, cv.INTER_LINEAR);
+        resized = new Uint8Array(dst.data);
+    }
+    finally {
+        src.delete();
+        dst.delete();
+    }
+    const padded = new Uint8Array(DET_SIZE * DET_SIZE * 3).fill(114);
+    for (let y = 0; y < h; y++)
+        padded.set(resized.subarray(y * w * 3, (y + 1) * w * 3), y * DET_SIZE * 3);
+    return { ratio: r, padded };
+}
+/** 单类 NMS（DetectionEngine.nms），float32 语义。 */
+function nms(boxes, scores, thr) {
+    const area = boxes.map(([x1, y1, x2, y2]) => f(f(f(x2 - x1) + 1) * f(f(y2 - y1) + 1)));
+    // scores.argsort()[::-1]：升序后倒过来
+    let order = scores
+        .map((s, i) => [s, i])
+        .sort((a, b) => a[0] - b[0] || a[1] - b[1])
+        .map(([, i]) => i)
+        .reverse();
+    const keep = [];
+    const t = f(thr);
+    while (order.length) {
+        const i = order[0];
+        keep.push(i);
+        const [ax1, ay1, ax2, ay2] = boxes[i];
+        order = order.slice(1).filter((j) => {
+            const [bx1, by1, bx2, by2] = boxes[j];
+            const w = Math.max(0, f(f(Math.min(ax2, bx2) - Math.max(ax1, bx1)) + 1));
+            const h = Math.max(0, f(f(Math.min(ay2, by2) - Math.max(ay1, by1)) + 1));
+            const inter = f(w * h);
+            return f(inter / f(f(area[i] + area[j]) - inter)) <= t;
+        });
+    }
+    return keep;
+}
+/** 检测字符框（DetectionEngine.get_bbox），返回 [x1, y1, x2, y2] 整数框，顺序同上游（按分数）。 */
+export async function detect(im) {
+    const { ratio, padded } = await detInput(im);
+    const plane = DET_SIZE * DET_SIZE;
+    const tensor = new Float32Array(3 * plane);
+    for (let i = 0; i < plane; i++)
+        for (let c = 0; c < 3; c++)
+            tensor[c * plane + i] = padded[i * 3 + c];
+    const { data, dims } = await run('det', tensor, [1, 3, DET_SIZE, DET_SIZE]);
+    const n = dims[1];
+    const width = dims[2];
+    const boxes = [];
+    const scores = [];
+    const thr = f(0.1);
+    const r = f(ratio);
+    let a = 0;
+    for (const stride of [8, 16, 32]) {
+        const size = DET_SIZE / stride;
+        for (let gy = 0; gy < size; gy++) {
+            for (let gx = 0; gx < size; gx++, a++) {
+                if (a >= n)
+                    break;
+                const o = a * width;
+                const cx = f((data[o] + gx) * stride);
+                const cy = f((data[o + 1] + gy) * stride);
+                const w = f(f(Math.exp(data[o + 2])) * stride);
+                const h = f(f(Math.exp(data[o + 3])) * stride);
+                const score = f(data[o + 4] * data[o + 5]);
+                if (!(score > thr))
+                    continue;
+                const hw = f(w / 2);
+                const hh = f(h / 2);
+                boxes.push([f(f(cx - hw) / r), f(f(cy - hh) / r), f(f(cx + hw) / r), f(f(cy + hh) / r)]);
+                scores.push(score);
+            }
+        }
+    }
+    if (!boxes.length)
+        return [];
+    return nms(boxes, scores, 0.45).map((i) => {
+        const [x1, y1, x2, y2] = boxes[i];
+        return [
+            x1 < 0 ? 0 : Math.trunc(x1),
+            y1 < 0 ? 0 : Math.trunc(y1),
+            x2 > im.width ? im.width : Math.trunc(x2),
+            y2 > im.height ? im.height : Math.trunc(y2),
+        ];
+    });
+}
+/** `classification(img, probability=True)`：灰度识别，返回文字和每一步的字符概率。 */
+export async function classify(im) {
+    const { width, height, gray } = ocrInput(im);
+    const input = new Float32Array(gray.length);
+    for (let i = 0; i < gray.length; i++)
+        input[i] = f(gray[i] / 255);
+    const { data, dims } = await run('ocr', input, [1, 1, height, width]);
+    // 输出是 [T, 1, C]（模型里声明的形状不对，按实际的来）
+    const classes = dims[dims.length - 1];
+    const steps = data.length / classes;
+    const cs = await charset();
+    const probabilities = new Float32Array(data.length);
+    let text = '';
+    let prev = -1;
+    for (let t = 0; t < steps; t++) {
+        const row = data.subarray(t * classes, (t + 1) * classes);
+        let max = -Infinity;
+        let arg = 0;
+        for (let c = 0; c < classes; c++) {
+            if (row[c] > max) {
+                max = row[c];
+                arg = c;
+            }
+        }
+        let sum = 0;
+        for (let c = 0; c < classes; c++)
+            sum += Math.exp(row[c] - max);
+        for (let c = 0; c < classes; c++)
+            probabilities[t * classes + c] = f(Math.exp(row[c] - max) / sum);
+        if (arg !== prev && arg !== 0 && arg < cs.length)
+            text += cs[arg];
+        prev = arg;
+    }
+    return { text, probabilities, steps, classes };
+}

package/dist/platforms/bilibili/web/gaia.js

@@ -0,0 +1,130 @@
+import { quote } from '../../../core/py.js';
+import * as rand from '../../../core/rand.js';
+import { PROFILE } from './profile.js';
+/**
+ * 风控指纹（上游 apis/bili_gaia_apis.py）。只移植明文上报 `ExClimbWuzhi` 这一路：
+ * 加密上报依赖 CDN 上的第三方 SDK，上游也默认不发，已实证写接口不受影响。
+ */
+const PLUGINS = [
+    'PDF Viewer',
+    'Chrome PDF Viewer',
+    'Chromium PDF Viewer',
+    'Microsoft Edge PDF Viewer',
+    'WebKit built-in PDF',
+].map((name) => [name, 'Portable Document Format', [['application/pdf', 'pdf'], ['text/pdf', 'pdf']]]);
+/** canvas 指纹尾串，同时是 qrcode/poll 的 b_ret。 */
+export const CANVAS_1 = 'mW9qAAAAAElFTkSuQmCC';
+const CANVAS_2 = '//TgNIfAAAAAZJREFUAwBde+3wgcxEHQAAAABJRU5ErkJggg==';
+const AUDIO_FP = '124.04347527516074';
+const PRECISIONS = ['vertex', 'fragment'].flatMap((shader) => ['high', 'medium', 'low'].flatMap((p) => [
+    `webgl ${shader} shader ${p} float precision:23`,
+    `webgl ${shader} shader ${p} float precision rangeMin:127`,
+    `webgl ${shader} shader ${p} float precision rangeMax:127`,
+]));
+const INT_PRECISIONS = ['vertex', 'fragment'].flatMap((shader) => ['high', 'medium', 'low'].flatMap((p) => [
+    `webgl ${shader} shader ${p} int precision:0`,
+    `webgl ${shader} shader ${p} int precision rangeMin:31`,
+    `webgl ${shader} shader ${p} int precision rangeMax:30`,
+]));
+const WEBGL_PARAMS = [
+    'extensions:ANGLE_instanced_arrays;EXT_blend_minmax;EXT_clip_control;' +
+        'EXT_color_buffer_half_float;EXT_depth_clamp;EXT_disjoint_timer_query;' +
+        'EXT_float_blend;EXT_frag_depth;EXT_polygon_offset_clamp;' +
+        'EXT_shader_texture_lod;EXT_texture_compression_bptc;' +
+        'EXT_texture_compression_rgtc;EXT_texture_filter_anisotropic;' +
+        'EXT_texture_mirror_clamp_to_edge;EXT_sRGB;KHR_parallel_shader_compile;' +
+        'OES_element_index_uint;OES_fbo_render_mipmap;OES_standard_derivatives;' +
+        'OES_texture_float;OES_texture_float_linear;OES_texture_half_float;' +
+        'OES_texture_half_float_linear;OES_vertex_array_object;' +
+        'WEBGL_blend_func_extended;WEBGL_color_buffer_float;' +
+        'WEBGL_compressed_texture_s3tc;WEBGL_compressed_texture_s3tc_srgb;' +
+        'WEBGL_debug_renderer_info;WEBGL_debug_shaders;WEBGL_depth_texture;' +
+        'WEBGL_draw_buffers;WEBGL_lose_context;WEBGL_multi_draw;' +
+        'WEBGL_polygon_mode',
+    'webgl aliased line width range:[1, 1]',
+    'webgl aliased point size range:[1, 1024]',
+    'webgl alpha bits:8',
+    'webgl antialiasing:yes',
+    'webgl blue bits:8',
+    'webgl depth bits:24',
+    'webgl green bits:8',
+    'webgl max anisotropy:16',
+    'webgl max combined texture image units:32',
+    'webgl max cube map texture size:16384',
+    'webgl max fragment uniform vectors:1024',
+    'webgl max render buffer size:16384',
+    'webgl max texture image units:16',
+    'webgl max texture size:16384',
+    'webgl max varying vectors:30',
+    'webgl max vertex attribs:16',
+    'webgl max vertex texture image units:16',
+    'webgl max vertex uniform vectors:4095',
+    'webgl max viewport dims:[32767, 32767]',
+    'webgl red bits:8',
+    'webgl renderer:WebKit WebGL',
+    'webgl shading language version:WebGL GLSL ES 1.0 (OpenGL ES GLSL ES 1.0 Chromium)',
+    'webgl stencil bits:0',
+    'webgl vendor:WebKit',
+    'webgl version:WebGL 1.0 (OpenGL ES 2.0 Chromium)',
+    'webgl unmasked vendor:Google Inc. (NVIDIA)',
+    'webgl unmasked renderer:ANGLE (NVIDIA, NVIDIA GeForce RTX 5060 Ti (0x00002D04) Direct3D11 vs_5_0 ps_5_0, D3D11)',
+    ...PRECISIONS,
+    ...INT_PRECISIONS,
+];
+/** `3c43` 指纹主体，也是 buvid_fp 的 murmur3 输入。键序照抄实抓。 */
+export function fingerCore() {
+    const w = PROFILE.screenWidth;
+    const h = PROFILE.screenHeight;
+    return new Map([
+        ['2673', 0],
+        ['5766', PROFILE.colorDepth],
+        ['6527', 0],
+        ['7003', 1],
+        ['807e', 1],
+        ['b8ce', PROFILE.ua],
+        ['641c', 0],
+        ['07a4', 'zh-CN'],
+        ['1c57', 32],
+        ['0bd0', PROFILE.hardwareConcurrency],
+        ['748e', [w, h]],
+        ['d61f', [w, h - 48]],
+        ['fc9d', -480],
+        ['6aa9', PROFILE.timezone],
+        ['75b8', 1],
+        ['3b21', 1],
+        ['8a1c', 0],
+        ['d52f', 'not available'],
+        ['adca', 'Win32'],
+        ['80c9', PLUGINS],
+        ['13ab', CANVAS_1],
+        ['bfe9', CANVAS_2],
+        ['a3c1', WEBGL_PARAMS],
+        ['6bc5', `${PROFILE.webglVendor}~${PROFILE.webglRenderer}`],
+        ['ed31', 0],
+        ['72bd', 0],
+        ['097b', 0],
+        ['52cd', [10, 0, 0]],
+        ['a658', []],
+        ['d02f', AUDIO_FP],
+    ]);
+}
+/** ExClimbWuzhi 的 payload 对象。 */
+export function fingerPayload(uuid, referer = 'https://www.bilibili.com/', correspondUrl = '') {
+    return new Map([
+        ['3064', 1],
+        ['5062', String(rand.now())],
+        ['03bf', quote(correspondUrl, '')],
+        ['39c8', '333.1193.fp.risk'],
+        ['34f1', ''],
+        ['d402', ''],
+        ['654a', ''],
+        ['6e7c', '0x0'],
+        ['3c43', fingerCore()],
+        ['54ef', '{}'],
+        ['8b94', quote(referer, '')],
+        ['df35', uuid],
+        ['07a4', 'zh-CN'],
+        ['5f45', null],
+        ['db46', 0],
+    ]);
+}

package/dist/platforms/bilibili/web/geetest-manual.js

@@ -0,0 +1,154 @@
+import { createServer } from 'node:http';
+import { SpecificAIError } from '../../../core/errors.js';
+import { interactive } from '../../../core/login.js';
+/** 上游默认端口；被占用时换一个空闲端口。 */
+const PORT = 8777;
+/** 秒。 */
+const TIMEOUT = 300;
+function page(gt, challenge) {
+    return `<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<title>B站登录 - 人机验证</title>
+<script src="https://static.geetest.com/static/tools/gt.js"></script>
+<style>
+  body { font-family: -apple-system, "Microsoft YaHei", sans-serif; background:#f6f7f9;
+         display:flex; align-items:center; justify-content:center; height:100vh; margin:0; }
+  .card { background:#fff; padding:32px 40px; border-radius:12px; text-align:center;
+          box-shadow:0 8px 30px rgba(0,0,0,.08); min-width:360px; }
+  h1 { font-size:18px; margin:0 0 6px; color:#18191c; }
+  p  { font-size:13px; color:#9499a0; margin:0 0 20px; }
+  #done { display:none; color:#00a1d6; font-size:15px; font-weight:600; margin-top:16px; }
+</style>
+</head>
+<body>
+<div class="card">
+  <h1>完成人机验证</h1>
+  <p>验证通过后本页会自动回传结果，可直接关闭</p>
+  <div id="captcha"></div>
+  <div id="done">验证已通过，结果已回传，可以关闭本页</div>
+</div>
+<script>
+initGeetest({
+  gt: ${JSON.stringify(gt)},
+  challenge: ${JSON.stringify(challenge)},
+  offline: false,
+  new_captcha: true,
+  product: "bind",
+  https: true
+}, function (captchaObj) {
+  captchaObj.onReady(function () { captchaObj.verify(); });
+  captchaObj.onSuccess(function () {
+    var r = captchaObj.getValidate();
+    window.__geetest_result = r;
+    fetch("/result", { method: "POST", body: JSON.stringify(r) });
+    document.getElementById("done").style.display = "block";
+  });
+});
+</script>
+</body>
+</html>
+`;
+}
+function listen(server, port) {
+    return new Promise((resolve, reject) => {
+        const onError = (err) => {
+            server.off('listening', onListening);
+            reject(err);
+        };
+        const onListening = () => {
+            server.off('error', onError);
+            resolve(server.address().port);
+        };
+        server.once('error', onError);
+        server.once('listening', onListening);
+        server.listen(port, '127.0.0.1');
+    });
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        req.on('error', reject);
+    });
+}
+/** 起本地验证页面（不检查 TTY，也不打印），返回地址和等待结果的 Promise。 */
+export async function serveManual(gt, challenge, options = {}) {
+    const timeout = options.timeout ?? TIMEOUT;
+    let current = {};
+    let settle;
+    const result = new Promise((resolve, reject) => (settle = { resolve, reject }));
+    result.catch(() => { });
+    const json = (res, status, payload) => {
+        const body = Buffer.from(JSON.stringify(payload));
+        res.writeHead(status, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', 'Content-Length': body.length });
+        res.end(body);
+    };
+    const server = createServer(async (req, res) => {
+        const path = new URL(req.url ?? '/', 'http://127.0.0.1').pathname;
+        if (req.method === 'POST') {
+            let r = {};
+            try {
+                r = JSON.parse((await readBody(req)) || '{}');
+            }
+            catch { }
+            const validate = typeof r.geetest_validate === 'string' ? r.geetest_validate : '';
+            if (!validate)
+                return json(res, 400, { ok: false });
+            current = r;
+            json(res, 200, { ok: true });
+            settle.resolve({
+                challenge: typeof r.geetest_challenge === 'string' && r.geetest_challenge ? r.geetest_challenge : challenge,
+                validate,
+                seccode: typeof r.geetest_seccode === 'string' && r.geetest_seccode ? r.geetest_seccode : `${validate}|jordan`,
+            });
+            return;
+        }
+        if (path === '/poll')
+            return json(res, 200, current);
+        // 每个 challenge 只能用一次，页面被缓存会报 GeetestError: old challenge
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store, no-cache, must-revalidate', Pragma: 'no-cache' });
+        res.end(page(gt, challenge));
+    });
+    let port;
+    try {
+        port = await listen(server, options.port ?? PORT);
+    }
+    catch (err) {
+        if (err.code !== 'EADDRINUSE' || options.port === 0)
+            throw err;
+        port = await listen(server, 0);
+    }
+    const timer = setTimeout(() => settle.reject(new SpecificAIError('RISK_CONTROL', `人机验证超时：${timeout} 秒内没有在浏览器里完成`, { hint: '重新执行命令', detail: { kind: 'captcha' } })), timeout * 1000);
+    const onAbort = () => settle.reject(new SpecificAIError('RISK_CONTROL', '人机验证已取消', { detail: { kind: 'captcha' } }));
+    options.signal?.addEventListener('abort', onAbort, { once: true });
+    const close = async () => {
+        clearTimeout(timer);
+        options.signal?.removeEventListener('abort', onAbort);
+        server.closeAllConnections();
+        await new Promise((resolve) => server.close(() => resolve()));
+    };
+    return { url: `http://127.0.0.1:${port}`, result, close };
+}
+/**
+ * 在浏览器里手动过极验。只在终端里可用（stdin 与 stderr 都是 TTY），否则报 RISK_CONTROL。
+ * 地址直接写到 stderr（-q 也会显示，这一步必须由用户操作）。
+ */
+export async function manualGeetest(ctx, gt, challenge, options = {}) {
+    if (!interactive()) {
+        throw new SpecificAIError('RISK_CONTROL', '需要在浏览器里手动完成人机验证，但当前不是交互式终端', {
+            hint: '在终端里重新执行这条命令，按提示在浏览器里完成验证',
+            detail: { kind: 'captcha' },
+        });
+    }
+    const s = await serveManual(gt, challenge, { ...options, signal: ctx.signal });
+    process.stderr.write(`[specific-ai] 请在浏览器打开 ${s.url} 完成人机验证（${options.timeout ?? TIMEOUT} 秒内），完成后自动继续\n`);
+    try {
+        return await s.result;
+    }
+    finally {
+        await s.close();
+    }
+}