tilion-fortress 151.0.7908

package/README.md

@@ -0,0 +1,79 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/tiliondev/fortress/main/docs/assets/dockerhub-banner.png" width="100%" alt="Fortress — stealth Chromium engine">
+</p>
+
+<h1 align="center">tilion-fortress</h1>
+
+<p align="center"><b>Drive the Fortress stealth Chromium engine with one line — no build, no Chromium source.</b></p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/tilion-fortress"><img src="https://img.shields.io/npm/v/tilion-fortress?logo=npm" alt="npm"></a>
+  <a href="https://www.npmjs.com/package/tilion-fortress"><img src="https://img.shields.io/node/v/tilion-fortress?logo=node.js&logoColor=white" alt="node"></a>
+  <a href="https://hub.docker.com/r/tilion/fortress"><img src="https://img.shields.io/docker/pulls/tilion/fortress?logo=docker&logoColor=white&label=docker%20pulls" alt="Docker Pulls"></a>
+  <a href="https://github.com/tiliondev/fortress"><img src="https://img.shields.io/github/stars/tiliondev/fortress?style=social" alt="Stars"></a>
+  <a href="https://github.com/tiliondev/fortress/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-BSD--3--Clause-blue" alt="License"></a>
+</p>
+
+---
+
+**Stop getting blocked — without `puppeteer-stealth`.** JavaScript stealth patches self-reveal: a detector checks whether a getter is native code and catches the override. Fortress compiles the fingerprint correction into Chromium's **C++**, so a page inspecting itself sees stock Chrome. It clears **CreepJS**, **Sannysoft**, **BrowserScan**, and live **Cloudflare** as a normal Chrome install.
+
+## Install
+
+```bash
+npm install tilion-fortress
+```
+
+On first launch it fetches the prebuilt Fortress binary for your platform from the official GitHub Release (SHA-256 verified) and caches it. No Chromium source, no compilation.
+
+## Quick start
+
+```js
+import { Fortress } from "tilion-fortress";
+import puppeteer from "puppeteer-core";
+
+const f = await Fortress.launch();                       // stealth engine on a CDP endpoint
+const browser = await puppeteer.connect({ browserURL: f.cdpUrl });
+const page = await browser.newPage();
+await page.goto("https://bot.sannysoft.com");
+await page.screenshot({ path: "all-green.png" });
+await browser.close();
+await f.close();
+```
+
+Keep your existing Puppeteer / Playwright / CDP code — just point it at `f.cdpUrl`. Works the same under **browser-use**, **Crawl4AI**, **Stagehand**, and **LangChain**.
+
+## Verified against live detectors
+
+| Suite | Result |
+|---|---|
+| **CreepJS** | 0% headless · 0% stealth |
+| **bot.sannysoft.com** | 0 failed · all green · WebGL = NVIDIA RTX 3060 / ANGLE D3D11 |
+| **browserscan.net** | "No bots detected, could be a human" |
+| **rebrowser bot-detector** | no `Runtime.enable` leak · `webdriver=false` |
+| **Cloudflare Turnstile** | cleared a live challenge |
+
+## Custom persona
+
+The default persona is a coherent Windows identity. Override any surface:
+
+```js
+const f = await Fortress.launch({
+  persona: { timezone: "America/Chicago", languages: "en-GB,en", hwConcurrency: 16 },
+  extraArgs: ["--window-size=1280,800"],
+});
+```
+
+## Platform support
+
+Linux x64 has a native prebuilt binary. On macOS / Windows the package transparently runs Fortress via the official Docker image (`tilion/fortress`) — Docker is the cross-OS vehicle until native Win/Mac builds ship.
+
+> **Still blocked?** ~90% of the time it's your **IP**, not your fingerprint — datacenter ranges are flagged before any page script runs. Route egress through a residential or mobile proxy and retry.
+
+## Links
+
+- **Source & docs:** https://github.com/tiliondev/fortress
+- **Agent guide:** https://github.com/tiliondev/fortress/blob/main/AGENTS.md
+- **Docker image:** https://hub.docker.com/r/tilion/fortress
+
+BSD-3-Clause · reproducible from source · monthly Chromium rebase · **Blink · V8 · BoringSSL** patched in-tree.

package/cli.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+// CLI: `tilion-fortress` — launch Fortress and print the CDP URL.
+import { Fortress, VERSION } from "./index.js";
+
+const args = process.argv.slice(2);
+if (args.includes("--version")) { console.log(`tilion-fortress ${VERSION}`); process.exit(0); }
+
+const portArg = args.indexOf("--port");
+const port = portArg >= 0 ? Number(args[portArg + 1]) : 9222;
+const headless = !args.includes("--no-headless");
+
+const f = await Fortress.launch({ port, headless });
+process.stderr.write(`Fortress up. CDP: ${f.cdpUrl}\n`);
+console.log(f.cdpUrl);
+process.on("SIGINT", async () => { await f.close(); process.exit(0); });
+setInterval(() => {}, 1 << 30);

package/index.js

@@ -0,0 +1,148 @@
+// tilion-fortress (Node) — install & drive the Fortress stealth Chromium engine.
+// Ships the prebuilt binary only (no engine source). Detects platform, downloads the
+// matching bundle from the GitHub Release, verifies SHA256, caches it, launches with CDP.
+// macOS/Windows fall back to the Docker image until native binaries are published.
+import { spawn, spawnSync } from "node:child_process";
+import { createWriteStream, existsSync, chmodSync, mkdirSync, createReadStream } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { createHash } from "node:crypto";
+
+export const VERSION = "151.0.7908.0";
+const REPO = "tiliondev/fortress";
+const TAG = `v${VERSION}`;
+const DOCKER_IMAGE = "tilion/fortress:latest";
+const CACHE = process.env.FORTRESS_BROWSERS_PATH || join(homedir(), ".cache", "tilion-fortress");
+const HOST = process.env.FORTRESS_DOWNLOAD_HOST || `https://github.com/${REPO}/releases/download/${TAG}`;
+
+// platform key -> { asset, kind, launcher }
+const ASSETS = {
+  "linux-x64": { asset: "tilion-fortress-linux-x64.tar.gz", kind: "tar", launcher: "tilion-fortress/tilion" },
+  "win-x64":   { asset: "tilion-fortress-win-x64.zip",       kind: "zip", launcher: "tilion-fortress/tilion.cmd" },
+  "mac-arm64": { asset: "tilion-fortress-mac-arm64.tar.gz",  kind: "tar", launcher: "tilion-fortress/tilion" },
+  "mac-x64":   { asset: "tilion-fortress-mac-x64.tar.gz",    kind: "tar", launcher: "tilion-fortress/tilion" },
+};
+
+export function resolvePlatform() {
+  const { platform, arch } = process;
+  if (platform === "linux" && arch === "x64") return "linux-x64";
+  if (platform === "win32" && arch === "x64") return "win-x64";
+  if (platform === "darwin") return arch === "arm64" ? "mac-arm64" : "mac-x64";
+  return null;
+}
+
+function personaArgs(persona) {
+  if (!persona) return [];
+  const map = { platform: "--uxr-platform", timezone: "--uxr-timezone", languages: "--uxr-languages",
+    webglRenderer: "--uxr-webgl-renderer", webglVendor: "--uxr-webgl-vendor",
+    hwConcurrency: "--uxr-hw-concurrency", deviceMemory: "--uxr-device-memory",
+    screenWidth: "--uxr-screen-width", screenHeight: "--uxr-screen-height", canvasSeed: "--uxr-canvas-seed" };
+  return Object.entries(persona).map(([k, v]) => `${map[k] || `--uxr-${k}`}=${v}`);
+}
+
+async function sha256(path) {
+  const h = createHash("sha256");
+  await pipeline(createReadStream(path), h);
+  return h.digest("hex");
+}
+
+async function expectedSha(asset) {
+  try {
+    const r = await fetch(`${HOST}/SHA256SUMS`);
+    if (!r.ok) return null;
+    for (const line of (await r.text()).split("\n")) {
+      const p = line.trim().split(/\s+/);
+      if (p.length === 2 && p[1].replace(/^\*/, "") === asset) return p[0].toLowerCase();
+    }
+  } catch { /* none */ }
+  return null;
+}
+
+async function ensureNative(plat) {
+  const { asset, kind, launcher } = ASSETS[plat];
+  const root = join(CACHE, VERSION, plat);
+  const launcherPath = join(root, launcher);
+  if (existsSync(launcherPath)) return launcherPath;
+  mkdirSync(root, { recursive: true });
+  const archive = join(root, asset);
+  process.stderr.write(`[tilion-fortress] downloading ${HOST}/${asset} ...\n`);
+  const res = await fetch(`${HOST}/${asset}`);
+  if (!res.ok) throw new Error(`download failed: ${res.status}`);
+  await pipeline(res.body, createWriteStream(archive));
+
+  const exp = await expectedSha(asset);
+  if (exp) {
+    const act = await sha256(archive);
+    if (act !== exp) throw new Error(`SHA256 mismatch for ${asset}: expected ${exp}, got ${act}`);
+    process.stderr.write("[tilion-fortress] SHA256 verified\n");
+  } else {
+    process.stderr.write("[tilion-fortress] WARNING: no SHA256SUMS published; skipping verification\n");
+  }
+
+  if (kind === "tar") {
+    if (spawnSync("tar", ["xzf", archive, "-C", root], { stdio: "inherit" }).status !== 0)
+      throw new Error("tar extraction failed");
+  } else { // zip (Windows): use PowerShell Expand-Archive
+    if (spawnSync("powershell", ["-NoProfile", "-Command",
+        `Expand-Archive -Force -LiteralPath '${archive}' -DestinationPath '${root}'`],
+        { stdio: "inherit" }).status !== 0) throw new Error("zip extraction failed");
+  }
+  if (!launcher.endsWith(".cmd") && existsSync(launcherPath)) chmodSync(launcherPath, 0o755);
+  if (!existsSync(launcherPath)) throw new Error(`launcher missing after extract: ${launcherPath}`);
+  return launcherPath;
+}
+
+async function assetExists(plat) {
+  try { return (await fetch(`${HOST}/${ASSETS[plat].asset}`, { method: "HEAD" })).ok; }
+  catch { return false; }
+}
+
+async function waitCdp(port, timeoutMs = 40000) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try { const r = await fetch(`http://127.0.0.1:${port}/json/version`); if (r.ok) return (await r.json()).webSocketDebuggerUrl; }
+    catch {}
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  throw new Error("Fortress CDP endpoint did not come up");
+}
+
+export class Fortress {
+  constructor({ port = 9222, persona = null, extraArgs = [], headless = true } = {}) {
+    Object.assign(this, { port, persona, extraArgs, headless, proc: null, dockerName: null, cdpUrl: null });
+  }
+  static async launch(opts) { return new Fortress(opts).start(); }
+
+  async start() {
+    const plat = resolvePlatform();
+    const native = plat && (plat === "linux-x64" || await assetExists(plat));
+    if (native) await this._startNative(plat); else this._startDocker();
+    this.cdpUrl = await waitCdp(this.port);
+    return this;
+  }
+
+  async _startNative(plat) {
+    const launcher = await ensureNative(plat);
+    const args = [];
+    if (this.headless) args.push("--headless=new", "--no-sandbox");
+    args.push(`--remote-debugging-port=${this.port}`, `--user-data-dir=${join(CACHE, "profile")}`,
+              ...personaArgs(this.persona), ...this.extraArgs);
+    this.proc = spawn(launcher, args, { stdio: "ignore", shell: launcher.endsWith(".cmd") });
+  }
+
+  _startDocker() {
+    if (spawnSync("docker", ["--version"]).status !== 0)
+      throw new Error("No native binary for this platform yet and Docker not installed. Install Docker Desktop or use Linux x64.");
+    this.dockerName = `tilion-fortress-${process.pid}-${this.port}`;
+    const args = ["run", "-d", "--rm", "--name", this.dockerName, "-p", `${this.port}:9222`, DOCKER_IMAGE,
+      ...personaArgs(this.persona), ...this.extraArgs];
+    if (spawnSync("docker", args, { stdio: "ignore" }).status !== 0) throw new Error("docker run failed");
+  }
+
+  async close() {
+    if (this.proc) { this.proc.kill(); this.proc = null; }
+    if (this.dockerName) { spawnSync("docker", ["rm", "-f", this.dockerName], { stdio: "ignore" }); this.dockerName = null; }
+  }
+}
+export default Fortress;

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "tilion-fortress",
+  "version": "151.0.7908",
+  "description": "Install and drive the Fortress stealth Chromium engine. Prebuilt binary, no source.",
+  "type": "module",
+  "main": "index.js",
+  "bin": { "tilion-fortress": "cli.js" },
+  "files": ["index.js", "cli.js", "README.md"],
+  "engines": { "node": ">=18" },
+  "keywords": ["chromium", "stealth", "browser", "automation", "anti-bot", "fortress", "tilion"],
+  "author": "arham766",
+  "license": "BSD-3-Clause",
+  "repository": { "type": "git", "url": "https://github.com/tiliondev/fortress.git" },
+  "homepage": "https://github.com/tiliondev/fortress"
+}