feat(sdk): dual-version channels — stable=Chromium 149 (default), latest=151

Adds a channel selector to both SDKs and the release/Docker layout so users can pick
the Chromium base:
- stable -> Fortress on Chromium 149.0.7827.232 (the recommended default; matches the
  Chrome version most real users run, so it blends in best)
- latest -> Chromium 151.0.7908.0 (newest engine)

Python: Fortress(channel="stable"|"latest") or FORTRESS_CHANNEL; caches per release tag.
Node:   Fortress.launch({channel}) / CHANNELS export; same env override.
Docker: tilion/fortress:149 and :151. README documents both. SHA-verified downloads unchanged.

Author: arham766

README.md

@@ -188,6 +188,30 @@ sudo apt install ./tilion-fortress_151.0.7908.0_amd64.deb && tilion https://exam
 > [!TIP]
 > The SDK ships the compiled build **plus `patches/`**, so you can rebuild the engine yourself and verify every surface correction against the source. Downloads are SHA-256-verified against the release `SHA256SUMS` automatically.
 
+### Versions
+
+Fortress ships on **two Chromium bases** — pick your trade-off between blend-in and currency:
+
+| Channel | Chromium | When to use |
+|---|---|---|
+| **`stable`** *(default)* | **149** | Recommended — matches the Chrome version the mass of real users run, so it blends in best |
+| **`latest`** | **151** | Newest engine (reports a version slightly ahead of stable) |
+
+```python
+Fortress().start()                     # Python: stable (149) by default
+Fortress(channel="latest").start()     # opt into 151
+```
+```js
+await Fortress.launch();               // Node: stable (149) by default
+await Fortress.launch({ channel: "latest" });
+```
+```bash
+docker run --rm -p 9222:9222 tilion/fortress:149   # or :151
+# or set FORTRESS_CHANNEL=latest for either SDK
+```
+
+Native binaries: **Linux x64** (both versions) + **Windows x64** (151); Windows-149 and macOS run via the Docker image.
+
 ### Drop it into your AI agent
 
 Fortress is the browser your agent drives: raw CDP on `:9222`, no stealth plugins to wire up. There are two ways in.

sdk/node/index.js

@@ -11,10 +11,16 @@ 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";
+// Two release channels. "stable" = Chromium 149 (recommended default — matches the Chrome version
+// the mass of real users run). "latest" = 151 (newest engine). Override with { channel } or the
+// FORTRESS_CHANNEL env var.
+export const CHANNELS = {
+  stable: { tag: "v149.0.7827.232", docker: "tilion/fortress:149" },
+  latest: { tag: "v151.0.7908.0",   docker: "tilion/fortress:151" },
+};
+const DEFAULT_CHANNEL = process.env.FORTRESS_CHANNEL || "stable";
 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}`;
+const hostFor = (tag) => process.env.FORTRESS_DOWNLOAD_HOST || `https://github.com/${REPO}/releases/download/${tag}`;
 
 // platform key -> { asset, kind, launcher }
 export const ASSETS = {
@@ -47,9 +53,9 @@ export async function sha256(path) {
   return h.digest("hex");
 }
 
-export async function expectedSha(asset) {
+export async function expectedSha(asset, host) {
   try {
-    const r = await fetch(`${HOST}/SHA256SUMS`);
+    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+/);
@@ -59,19 +65,19 @@ export async function expectedSha(asset) {
   return null;
 }
 
-async function ensureNative(plat) {
+async function ensureNative(plat, host, tag) {
   const { asset, kind, launcher } = ASSETS[plat];
-  const root = join(CACHE, VERSION, plat);
+  const root = join(CACHE, tag, plat);   // cache per release tag so channels don't collide
   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}`);
+  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);
+  const exp = await expectedSha(asset, host);
   if (exp) {
     const act = await sha256(archive);
     if (act !== exp) throw new Error(`SHA256 mismatch for ${asset}: expected ${exp}, got ${act}`);
@@ -93,8 +99,8 @@ async function ensureNative(plat) {
   return launcherPath;
 }
 
-async function assetExists(plat) {
-  try { return (await fetch(`${HOST}/${ASSETS[plat].asset}`, { method: "HEAD" })).ok; }
+async function assetExists(plat, host) {
+  try { return (await fetch(`${host}/${ASSETS[plat].asset}`, { method: "HEAD" })).ok; }
   catch { return false; }
 }
 
@@ -109,21 +115,24 @@ async function waitCdp(port, timeoutMs = 40000) {
 }
 
 export class Fortress {
-  constructor({ port = 9222, persona = null, extraArgs = [], headless = true } = {}) {
-    Object.assign(this, { port, persona, extraArgs, headless, proc: null, dockerName: null, cdpUrl: null });
+  constructor({ port = 9222, persona = null, extraArgs = [], headless = true, channel = DEFAULT_CHANNEL } = {}) {
+    if (!CHANNELS[channel]) throw new Error(`unknown channel '${channel}'; use one of ${Object.keys(CHANNELS)}`);
+    const { tag, docker } = CHANNELS[channel];
+    Object.assign(this, { port, persona, extraArgs, headless, channel, tag, docker, host: hostFor(tag),
+                          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));
+    const native = plat && (plat === "linux-x64" || await assetExists(plat, this.host));
     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 launcher = await ensureNative(plat, this.host, this.tag);
     const args = [];
     if (this.headless) args.push("--headless=new", "--no-sandbox");
     args.push(`--remote-debugging-port=${this.port}`, `--user-data-dir=${join(CACHE, "profile")}`,
@@ -135,7 +144,7 @@ export class Fortress {
     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,
+    const args = ["run", "-d", "--rm", "--name", this.dockerName, "-p", `${this.port}:9222`, this.docker,
       ...personaArgs(this.persona), ...this.extraArgs];
     if (spawnSync("docker", args, { stdio: "ignore" }).status !== 0) throw new Error("docker run failed");
   }

sdk/node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tilion-fortress",
-  "version": "151.0.7908",
+  "version": "151.0.7909",
   "description": "Install and drive the Fortress stealth Chromium engine. Prebuilt binary, no source.",
   "type": "module",
   "main": "index.js",

sdk/python/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilion-fortress"
-version = "151.0.7908.0.post1"
+version = "151.0.7908.0.post3"
 description = "Install and drive the Fortress stealth Chromium engine. Prebuilt binary, no source."
 readme = "README.md"
 requires-python = ">=3.8"

sdk/python/tests/test_sdk.py

@@ -101,35 +101,50 @@ def test_expected_sha_parses_matching_asset(monkeypatch):
         f"deadbeef  tilion-fortress-win-x64.zip\n"
     ).encode()
     monkeypatch.setattr(tf.urllib.request, "urlopen", lambda *a, **k: _FakeResp(body))
-    assert tf._expected_sha(asset) == "aa11bb22"
+    assert tf._expected_sha(asset, "https://h") == "aa11bb22"
 
 
 def test_expected_sha_handles_starred_binary_marker(monkeypatch):
     # `sha256sum` writes "<hash> *<file>" in binary mode; the parser strips the leading '*'.
     asset = tf._ASSETS["linux-x64"][0]
     body = f"cafef00d *{asset}\n".encode()
     monkeypatch.setattr(tf.urllib.request, "urlopen", lambda *a, **k: _FakeResp(body))
-    assert tf._expected_sha(asset) == "cafef00d"
+    assert tf._expected_sha(asset, "https://h") == "cafef00d"
 
 
 def test_expected_sha_returns_none_when_absent(monkeypatch):
     body = b"aa11bb22  some-other-asset.tar.gz\n"
     monkeypatch.setattr(tf.urllib.request, "urlopen", lambda *a, **k: _FakeResp(body))
-    assert tf._expected_sha(tf._ASSETS["linux-x64"][0]) is None
+    assert tf._expected_sha(tf._ASSETS["linux-x64"][0], "https://h") is None
 
 
 def test_expected_sha_swallows_network_error(monkeypatch):
     def boom(*a, **k):
         raise OSError("network down")
     monkeypatch.setattr(tf.urllib.request, "urlopen", boom)
     # Must degrade to None (caller then warns + skips), never raise.
-    assert tf._expected_sha("anything") is None
+    assert tf._expected_sha("anything", "https://h") is None
 
 
 # --------------------------------------------------------------------------- release wiring
-def test_version_and_tag_are_coherent():
+def test_channels_are_coherent():
     import re
     assert re.fullmatch(r"\d+\.\d+\.\d+.*", tf.__version__)
-    assert re.fullmatch(r"v\d+\.\d+\.\d+\.\d+", tf._TAG)
     assert tf._REPO == "tiliondev/fortress"
-    assert tf._DOCKER_IMAGE.startswith("tilion/fortress")
+    assert tf._DEFAULT_CHANNEL in tf._CHANNELS
+    assert tf._DEFAULT_CHANNEL == "stable"          # 149 is the recommended default
+    for ch, cfg in tf._CHANNELS.items():
+        assert re.fullmatch(r"v\d+\.\d+\.\d+\.\d+", cfg["tag"])
+        assert cfg["docker"].startswith("tilion/fortress")
+    assert tf._CHANNELS["stable"]["tag"].startswith("v149")
+    assert tf._CHANNELS["latest"]["tag"].startswith("v151")
+
+
+def test_channel_resolution():
+    assert tf.Fortress(channel="stable")._tag == "v149.0.7827.232"
+    assert tf.Fortress(channel="latest")._tag == "v151.0.7908.0"
+    assert tf.Fortress()._tag == tf.Fortress(channel=tf._DEFAULT_CHANNEL)._tag
+    try:
+        tf.Fortress(channel="nope"); assert False
+    except ValueError:
+        pass

sdk/python/tilion_fortress/__init__.py

@@ -14,16 +14,25 @@
 import hashlib, json, os, platform, shutil, subprocess, sys, tarfile, time, urllib.request, zipfile
 from pathlib import Path
 
-__version__ = "151.0.7908.0.post1"
+__version__ = "151.0.7908.0.post3"
 __all__ = ["Fortress", "resolve_platform"]
 
 _REPO = "tiliondev/fortress"
-_TAG = "v151.0.7908.0"   # engine release tag (decoupled from package version)
-_DOCKER_IMAGE = "tilion/fortress:latest"
+# Two release channels. "stable" = Chromium 149 (the recommended default — it matches the Chrome
+# version the mass of real users run, so it blends in best). "latest" = 151 (newest engine).
+# Override per-instance with channel=..., or globally with the FORTRESS_CHANNEL env var.
+_CHANNELS = {
+    "stable": {"tag": "v149.0.7827.232", "docker": "tilion/fortress:149"},
+    "latest": {"tag": "v151.0.7908.0",   "docker": "tilion/fortress:151"},
+}
+_DEFAULT_CHANNEL = os.environ.get("FORTRESS_CHANNEL", "stable")
 _CACHE = Path(os.environ.get("FORTRESS_BROWSERS_PATH",
                              Path.home() / ".cache" / "tilion-fortress"))
-_HOST = os.environ.get("FORTRESS_DOWNLOAD_HOST",
-                       f"https://github.com/{_REPO}/releases/download/{_TAG}")
+
+
+def _host(tag: str) -> str:
+    return os.environ.get("FORTRESS_DOWNLOAD_HOST",
+                          f"https://github.com/{_REPO}/releases/download/{tag}")
 
 # platform key -> (release asset, archive kind, launcher relative path)
 _ASSETS = {
@@ -53,10 +62,10 @@ def _sha256(path: Path) -> str:
     return h.hexdigest()
 
 
-def _expected_sha(asset: str) -> str | None:
+def _expected_sha(asset: str, host: str) -> str | None:
     """Fetch SHA256SUMS from the release and return the hash for `asset`."""
     try:
-        with urllib.request.urlopen(f"{_HOST}/SHA256SUMS", timeout=30) as r:
+        with urllib.request.urlopen(f"{host}/SHA256SUMS", timeout=30) as r:
             for line in r.read().decode().splitlines():
                 parts = line.split()
                 if len(parts) == 2 and parts[1].lstrip("*") == asset:
@@ -66,20 +75,20 @@ def _expected_sha(asset: str) -> str | None:
     return None
 
 
-def _download(plat: str) -> Path:
+def _download(plat: str, host: str, tag: str) -> Path:
     """Ensure the bundle for `plat` is present + verified; return the launcher path."""
     asset, kind, launcher_rel = _ASSETS[plat]
-    root = _CACHE / __version__ / plat
+    root = _CACHE / tag / plat   # cache per release tag so channels don't collide
     launcher = root / launcher_rel
     if launcher.exists():
         return launcher
     root.mkdir(parents=True, exist_ok=True)
     archive = root / asset
-    url = f"{_HOST}/{asset}"
+    url = f"{host}/{asset}"
     sys.stderr.write(f"[tilion-fortress] downloading {url} ...\n")
     urllib.request.urlretrieve(url, archive)
 
-    expected = _expected_sha(asset)
+    expected = _expected_sha(asset, host)
     if expected:
         actual = _sha256(archive)
         if actual != expected:
@@ -120,8 +129,16 @@ class Fortress:
     """A running Fortress instance exposing a CDP endpoint at ``cdp_url``."""
 
     def __init__(self, port: int = 9222, persona: dict | None = None,
-                 extra_args: list[str] | None = None, headless: bool = True):
+                 extra_args: list[str] | None = None, headless: bool = True,
+                 channel: str | None = None):
         self.port, self.persona, self.extra_args, self.headless = port, persona, extra_args or [], headless
+        ch = channel or _DEFAULT_CHANNEL
+        if ch not in _CHANNELS:
+            raise ValueError(f"unknown channel {ch!r}; use one of {list(_CHANNELS)}")
+        self.channel = ch
+        self._tag = _CHANNELS[ch]["tag"]
+        self._docker = _CHANNELS[ch]["docker"]
+        self._host = _host(self._tag)
         self._proc = self._docker_name = self.cdp_url = None
 
     def start(self) -> "Fortress":
@@ -135,18 +152,17 @@ def start(self) -> "Fortress":
         self.cdp_url = self._wait_cdp()
         return self
 
-    @staticmethod
-    def _asset_exists(plat: str) -> bool:
+    def _asset_exists(self, plat: str) -> bool:
         asset = _ASSETS[plat][0]
         try:
-            req = urllib.request.Request(f"{_HOST}/{asset}", method="HEAD")
+            req = urllib.request.Request(f"{self._host}/{asset}", method="HEAD")
             with urllib.request.urlopen(req, timeout=15):
                 return True
         except Exception:
             return False
 
     def _start_native(self, plat: str):
-        launcher = _download(plat)
+        launcher = _download(plat, self._host, self._tag)
         args = [str(launcher)]
         if self.headless:
             args += ["--headless=new", "--no-sandbox"]
@@ -161,7 +177,7 @@ def _start_docker(self):
                 "Install Docker Desktop, or run on Linux x64.")
         self._docker_name = f"tilion-fortress-{os.getpid()}-{self.port}"
         args = ["docker", "run", "-d", "--rm", "--name", self._docker_name,
-                "-p", f"{self.port}:9222", _DOCKER_IMAGE] + _persona_args(self.persona) + self.extra_args
+                "-p", f"{self.port}:9222", self._docker] + _persona_args(self.persona) + self.extra_args
         subprocess.run(args, check=True, stdout=subprocess.DEVNULL)
 
     def _wait_cdp(self, timeout: float = 40.0) -> str: