specific-ai-cli 0.0.0-stage → 0.1.1

package/dist/platforms/jd/web/jcap/host.js

@@ -0,0 +1,107 @@
+import cp from 'node:child_process';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+/**
+ * JCAP 子进程的预加载（node --import），run.js 原样运行，这里只做两处宿主适配：
+ *
+ * 1. run.js 用 `spawnSync(python, [http_bridge.py | captcha_solver.py, ...])` 起网络桥和图像求解器，
+ *    这两种调用换成 `node helper.js bridge|solve ...`，入参出参协议不变。
+ * 2. env_core.js 用递归 Proxy 包住 document / navigator 及其返回的对象。上游的 jsdom 25 靠 impl 符号做品牌检查，
+ *    Proxy 能透传；jsdom 30 用私有字段，Proxy 当 this 或参数时一律报"不是合法实例"。这里记下 env_core 的每个 Proxy
+ *    包的目标，jsdom 取 impl 时先换回目标，效果与 jsdom 25 下一致。
+ * 3. env_core.init() 把全局的 Buffer / process 藏成 undefined（让 JCAP 看不出 Node）；jsdom 30 的依赖
+ *    （@exodus/bytes 等）解析 URL 时要用 Buffer。藏起来的这两个全局改成访问器：调用方在 node_modules 里时
+ *    给真对象，其余（JCAP 包）仍是 undefined。
+ */
+const execPath = process.execPath;
+const helper = process.env.SPECIFIC_AI_JD_HELPER ?? '';
+const original = cp.spawnSync;
+cp.spawnSync = function (command, args, options) {
+    const list = Array.isArray(args) ? args : [];
+    const script = String(list[0] ?? '');
+    if (helper && script.endsWith('http_bridge.py'))
+        return original.call(cp, execPath, [helper, 'bridge'], options ?? {});
+    if (helper && script.endsWith('captcha_solver.py'))
+        return original.call(cp, execPath, [helper, 'solve', ...list.slice(1)], options ?? {});
+    return original.call(cp, command, args, options);
+};
+const targets = new WeakMap();
+const NativeProxy = Proxy;
+const source = Function.prototype.toString;
+/** 只处理 env_core.createProxy 造的 Proxy（jsdom 自己也用 Proxy，那些不能动）。 */
+const isEnvCoreHandler = (h) => {
+    const get = h?.get;
+    try {
+        return typeof get === 'function' && source.call(get).includes('recordUndefined');
+    }
+    catch {
+        return false;
+    }
+};
+globalThis.Proxy = new NativeProxy(NativeProxy, {
+    construct(T, args, newTarget) {
+        const p = Reflect.construct(T, args, newTarget);
+        if (args[0] && (typeof args[0] === 'object' || typeof args[0] === 'function') && isEnvCoreHandler(args[1]))
+            targets.set(p, args[0]);
+        return p;
+    },
+});
+const unwrap = (v) => (v && (typeof v === 'object' || typeof v === 'function') && targets.has(v) ? unwrap(targets.get(v)) : v);
+// jsdom 30 用私有字段做品牌检查（`#impl in wrapper`），Proxy 永远过不了；生成代码经 utils 的这几个函数取 impl。
+// 在 jsdom 加载之前先载入它的 utils 并替换：参数或 this 是 env_core 的 Proxy 时先换成被包的对象。
+{
+    const req = createRequire(process.argv[1] ?? import.meta.url);
+    const utils = req(join(dirname(req.resolve('jsdom')), 'generated', 'idl', 'utils.js'));
+    for (const name of ['implForWrapper', 'implForWrapperWithInterface', 'tryImplForWrapper']) {
+        const fn = utils[name];
+        utils[name] = (wrapper, ...rest) => fn(unwrap(wrapper), ...rest);
+    }
+}
+const nativeLike = (fn, name) => {
+    Object.defineProperty(fn, 'name', { value: name });
+    Object.defineProperty(fn, 'toString', { value: () => `function ${name}() { [native code] }` });
+    return fn;
+};
+const realGlobals = { Buffer: globalThis.Buffer, process: globalThis.process };
+const nativeDefine = Object.defineProperty;
+/** 访问全局的调用方是否在依赖包里（不经 run.js 自定义的 prepareStackTrace）。 */
+function fromDependency(self) {
+    const prepare = Error.prepareStackTrace;
+    const limit = Error.stackTraceLimit;
+    try {
+        Error.stackTraceLimit = 2;
+        Error.prepareStackTrace = (_e, frames) => frames;
+        const holder = {};
+        Error.captureStackTrace(holder, self);
+        const frames = holder.stack;
+        const file = String(frames?.[0]?.getFileName() ?? '');
+        return /[\\/]node_modules[\\/]/.test(file) || file.startsWith('node:');
+    }
+    catch {
+        return false;
+    }
+    finally {
+        Error.prepareStackTrace = prepare;
+        Error.stackTraceLimit = limit;
+    }
+}
+Object.defineProperty = nativeLike(function defineProperty(o, key, d) {
+    if (o === globalThis && (key === 'Buffer' || key === 'process') && d && 'value' in d && d.value === undefined) {
+        const real = realGlobals[key];
+        let override = null;
+        const get = function () {
+            if (override)
+                return override.value;
+            return fromDependency(get) ? real : undefined;
+        };
+        return nativeDefine(o, key, {
+            configurable: true,
+            enumerable: false,
+            get,
+            set(value) {
+                override = { value };
+            },
+        });
+    }
+    return nativeDefine(o, key, d);
+}, 'defineProperty');

package/dist/platforms/jd/web/jcap/lsd.js

@@ -0,0 +1,300 @@
+import { fromMat, toMat, withMats } from '../../../../core/image.js';
+/**
+ * OpenCV 5.0 的 LineSegmentDetector（modules/imgproc/src/lsd.cpp，LSD_REFINE_STD，默认参数）移植。
+ * opencv-js 没有编译进 LSD；这里逐行照搬，C++ 里的 float 运算用 Math.fround 模拟。
+ * 返回 float32 的线段 (x1, y1, x2, y2)。
+ */
+const f = Math.fround;
+const PI = Math.PI;
+const M_3_2_PI = (3 * PI) / 2;
+const M_2__PI = 2 * PI;
+const NOTDEF = -1024.0;
+const DEG_TO_RADS = PI / 180;
+const P1 = f(f(0.9997878412794807) * f(180 / PI));
+const P3 = f(f(-0.3258083974640975) * f(180 / PI));
+const P5 = f(f(0.1555786518463281) * f(180 / PI));
+const P7 = f(f(-0.04432655554792128) * f(180 / PI));
+const EPS = f(2.220446049250313e-16);
+/** cv::fastAtan2（桌面版多项式近似，单位度）。 */
+export function fastAtan2(y, x) {
+    y = f(y);
+    x = f(x);
+    const ax = Math.abs(x);
+    const ay = Math.abs(y);
+    const poly = (c) => {
+        const c2 = f(c * c);
+        let t = f(P7 * c2);
+        t = f(t + P5);
+        t = f(t * c2);
+        t = f(t + P3);
+        t = f(t * c2);
+        t = f(t + P1);
+        return f(t * c);
+    };
+    let a;
+    if (ax >= ay)
+        a = poly(f(ay / f(ax + EPS)));
+    else
+        a = f(90 - poly(f(ax / f(ay + EPS))));
+    if (x < 0)
+        a = f(180 - a);
+    if (y < 0)
+        a = f(360 - a);
+    return a;
+}
+function angleDiffSigned(a, b) {
+    let diff = a - b;
+    while (diff <= -PI)
+        diff += M_2__PI;
+    while (diff > PI)
+        diff -= M_2__PI;
+    return diff;
+}
+const angleDiff = (a, b) => Math.abs(angleDiffSigned(a, b));
+const distSq = (x1, y1, x2, y2) => (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
+const dist = (x1, y1, x2, y2) => Math.sqrt(distSq(x1, y1, x2, y2));
+function doubleEqual(a, b) {
+    if (a === b)
+        return true;
+    const absDiff = Math.abs(a - b);
+    let absMax = Math.max(Math.abs(a), Math.abs(b));
+    if (absMax < 2.2250738585072014e-308)
+        absMax = 2.2250738585072014e-308;
+    return absDiff / absMax <= 100.0 * 2.220446049250313e-16;
+}
+/** cv2.createLineSegmentDetector(cv2.LSD_REFINE_STD).detect(gray)[0]。gray 是 8 位单通道。 */
+export function detectLines(cv, gray) {
+    const SCALE = 0.8;
+    const SIGMA_SCALE = 0.6;
+    const QUANT = 2.0;
+    const ANG_TH = 22.5;
+    const DENSITY_TH = 0.7;
+    const N_BINS = 1024;
+    const prec = (PI * ANG_TH) / 180;
+    const p = ANG_TH / 180;
+    const rho = QUANT / Math.sin(prec);
+    // GaussianBlur + resize(INTER_LINEAR_EXACT)
+    const scaled = withMats((keep) => {
+        const src = keep(toMat(cv, gray));
+        const blurred = keep(new cv.Mat());
+        const sigma = SIGMA_SCALE / SCALE;
+        const h = Math.ceil(sigma * Math.sqrt(2 * 3 * Math.log(10.0))) >>> 0;
+        cv.GaussianBlur(src, blurred, new cv.Size(1 + 2 * h, 1 + 2 * h), sigma);
+        const out = keep(new cv.Mat());
+        cv.resize(blurred, out, new cv.Size(0, 0), SCALE, SCALE, cv.INTER_LINEAR_EXACT);
+        return fromMat(cv, out);
+    });
+    const W = scaled.width;
+    const H = scaled.height;
+    const px = scaled.data;
+    const angles = new Float64Array(W * H);
+    const modgrad = new Float64Array(W * H);
+    for (let x = 0; x < W; x++)
+        angles[(H - 1) * W + x] = NOTDEF;
+    for (let y = 0; y < H; y++)
+        angles[y * W + W - 1] = NOTDEF;
+    // ll_angle
+    let maxGrad = -1;
+    for (let y = 0; y < H - 1; y++) {
+        for (let x = 0; x < W - 1; x++) {
+            const DA = px[(y + 1) * W + x + 1] - px[y * W + x];
+            const BC = px[y * W + x + 1] - px[(y + 1) * W + x];
+            const gx = DA + BC;
+            const gy = DA - BC;
+            const norm = Math.sqrt((gx * gx + gy * gy) / 4.0);
+            modgrad[y * W + x] = norm;
+            if (norm <= rho)
+                angles[y * W + x] = NOTDEF;
+            else {
+                angles[y * W + x] = fastAtan2(gx, -gy) * DEG_TO_RADS;
+                if (norm > maxGrad)
+                    maxGrad = norm;
+            }
+        }
+    }
+    const binCoef = maxGrad > 0 ? (N_BINS - 1) / maxGrad : 0;
+    const ordered = [];
+    for (let y = 0; y < H - 1; y++)
+        for (let x = 0; x < W - 1; x++)
+            ordered.push({ x, y, norm: Math.trunc(modgrad[y * W + x] * binCoef) });
+    ordered.sort((a, b) => b.norm - a.norm);
+    const LOG_NT = (5 * (Math.log10(W) + Math.log10(H))) / 2 + Math.log10(11.0);
+    const minRegSize = Math.trunc(-LOG_NT / Math.log10(p));
+    const used = new Uint8Array(W * H);
+    const isAligned = (x, y, theta, pr) => {
+        if (x < 0 || y < 0 || x >= W || y >= H)
+            return false;
+        const a = angles[y * W + x];
+        if (a === NOTDEF)
+            return false;
+        let n = theta - a;
+        if (n < 0)
+            n = -n;
+        if (n > M_3_2_PI) {
+            n -= M_2__PI;
+            if (n < 0)
+                n = -n;
+        }
+        return n <= pr;
+    };
+    const regionGrow = (sx, sy, reg, pr) => {
+        reg.length = 0;
+        let regAngle = angles[sy * W + sx];
+        reg.push({ x: sx, y: sy, angle: regAngle, modgrad: modgrad[sy * W + sx] });
+        let sumdx = f(Math.cos(regAngle));
+        let sumdy = f(Math.sin(regAngle));
+        used[sy * W + sx] = 1;
+        for (let i = 0; i < reg.length; i++) {
+            const r = reg[i];
+            const xxMin = Math.max(r.x - 1, 0);
+            const xxMax = Math.min(r.x + 1, W - 1);
+            const yyMin = Math.max(r.y - 1, 0);
+            const yyMax = Math.min(r.y + 1, H - 1);
+            for (let yy = yyMin; yy <= yyMax; yy++) {
+                for (let xx = xxMin; xx <= xxMax; xx++) {
+                    const k = yy * W + xx;
+                    if (used[k] !== 1 && isAligned(xx, yy, regAngle, pr)) {
+                        const angle = angles[k];
+                        used[k] = 1;
+                        reg.push({ x: xx, y: yy, angle, modgrad: modgrad[k] });
+                        sumdx = f(sumdx + f(Math.cos(f(angle))));
+                        sumdy = f(sumdy + f(Math.sin(f(angle))));
+                        regAngle = fastAtan2(sumdy, sumdx) * DEG_TO_RADS;
+                    }
+                }
+            }
+        }
+        return regAngle;
+    };
+    const getTheta = (reg, x, y, regAngle, pr) => {
+        let Ixx = 0;
+        let Iyy = 0;
+        let Ixy = 0;
+        for (const r of reg) {
+            const dx = r.x - x;
+            const dy = r.y - y;
+            Ixx += dy * dy * r.modgrad;
+            Iyy += dx * dx * r.modgrad;
+            Ixy -= dx * dy * r.modgrad;
+        }
+        if (doubleEqual(Ixx, 0) && doubleEqual(Iyy, 0) && doubleEqual(Ixy, 0))
+            throw new Error('LSD: 惯性矩阵为零');
+        const lambda = 0.5 * (Ixx + Iyy - Math.sqrt((Ixx - Iyy) * (Ixx - Iyy) + 4.0 * Ixy * Ixy));
+        let theta = Math.abs(Ixx) > Math.abs(Iyy) ? fastAtan2(lambda - Ixx, Ixy) : fastAtan2(Ixy, lambda - Iyy);
+        theta *= DEG_TO_RADS;
+        if (angleDiff(theta, regAngle) > pr)
+            theta += PI;
+        return theta;
+    };
+    const region2rect = (reg, regAngle, pr, pp) => {
+        let x = 0;
+        let y = 0;
+        let sum = 0;
+        for (const r of reg) {
+            x += r.x * r.modgrad;
+            y += r.y * r.modgrad;
+            sum += r.modgrad;
+        }
+        if (!(sum > 0))
+            throw new Error('LSD: 权重和为零');
+        x /= sum;
+        y /= sum;
+        const theta = getTheta(reg, x, y, regAngle, pr);
+        const dx = Math.cos(theta);
+        const dy = Math.sin(theta);
+        let lMin = 0;
+        let lMax = 0;
+        let wMin = 0;
+        let wMax = 0;
+        for (const r of reg) {
+            const rdx = r.x - x;
+            const rdy = r.y - y;
+            const l = rdx * dx + rdy * dy;
+            const w = -rdx * dy + rdy * dx;
+            if (l > lMax)
+                lMax = l;
+            else if (l < lMin)
+                lMin = l;
+            if (w > wMax)
+                wMax = w;
+            else if (w < wMin)
+                wMin = w;
+        }
+        const rec = { x1: x + lMin * dx, y1: y + lMin * dy, x2: x + lMax * dx, y2: y + lMax * dy, width: wMax - wMin, x, y, theta, dx, dy, prec: pr, p: pp };
+        if (rec.width < 1.0)
+            rec.width = 1.0;
+        return rec;
+    };
+    const reduceRegionRadius = (reg, regAngle, pr, pp, rec, density) => {
+        const xc = reg[0].x;
+        const yc = reg[0].y;
+        const r1 = distSq(xc, yc, rec.x1, rec.y1);
+        const r2 = distSq(xc, yc, rec.x2, rec.y2);
+        let radSq = r1 > r2 ? r1 : r2;
+        while (density < DENSITY_TH) {
+            radSq *= 0.75 * 0.75;
+            for (let i = 0; i < reg.length; i++) {
+                if (distSq(xc, yc, reg[i].x, reg[i].y) > radSq) {
+                    used[reg[i].y * W + reg[i].x] = 0;
+                    const last = reg.length - 1;
+                    [reg[i], reg[last]] = [reg[last], reg[i]];
+                    reg.pop();
+                    i--;
+                }
+            }
+            if (reg.length < 2)
+                return null;
+            rec = region2rect(reg, regAngle, pr, pp);
+            density = reg.length / (dist(rec.x1, rec.y1, rec.x2, rec.y2) * rec.width);
+        }
+        return rec;
+    };
+    const refine = (reg, regAngle, pr, pp, rec) => {
+        let density = reg.length / (dist(rec.x1, rec.y1, rec.x2, rec.y2) * rec.width);
+        if (density >= DENSITY_TH)
+            return rec;
+        const xc = reg[0].x;
+        const yc = reg[0].y;
+        const angC = reg[0].angle;
+        let sum = 0;
+        let sSum = 0;
+        let n = 0;
+        for (const r of reg) {
+            used[r.y * W + r.x] = 0;
+            if (dist(xc, yc, r.x, r.y) < rec.width) {
+                const d = angleDiffSigned(r.angle, angC);
+                sum += d;
+                sSum += d * d;
+                n++;
+            }
+        }
+        if (n <= 0)
+            throw new Error('LSD: refine 没有点');
+        const mean = sum / n;
+        const tau = 2.0 * Math.sqrt((sSum - 2.0 * mean * sum) / n + mean * mean);
+        regAngle = regionGrow(xc, yc, reg, tau);
+        if (reg.length < 2)
+            return null;
+        rec = region2rect(reg, regAngle, pr, pp);
+        density = reg.length / (dist(rec.x1, rec.y1, rec.x2, rec.y2) * rec.width);
+        if (density < DENSITY_TH)
+            return reduceRegionRadius(reg, regAngle, pr, pp, rec, density);
+        return rec;
+    };
+    const lines = [];
+    const reg = [];
+    for (const pt of ordered) {
+        const k = pt.y * W + pt.x;
+        if (used[k] !== 0 || angles[k] === NOTDEF)
+            continue;
+        const regAngle = regionGrow(pt.x, pt.y, reg, prec);
+        if (reg.length < minRegSize)
+            continue;
+        let rec = region2rect(reg, regAngle, prec, p);
+        rec = refine(reg, regAngle, prec, p, rec);
+        if (!rec)
+            continue;
+        lines.push([f((rec.x1 + 0.5) / SCALE), f((rec.y1 + 0.5) / SCALE), f((rec.x2 + 0.5) / SCALE), f((rec.y2 + 0.5) / SCALE)]);
+    }
+    return lines;
+}