Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++

Release wiring: release feed key and Tauri updater key, GitHub Releases feed address in the installers, versions 0.1.45.3 and 0.2.0-beta

Niko122198b865c56fb1
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 11faf4c43..7ba7ee634 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,7 +8,7 @@
# below refuses anything older: silently building for a pre-Ampere arch would produce a binary that runs
# and is wrong about its own performance, which is the worst of both outcomes.
cmake_minimum_required(VERSION 3.24)
-project(strata VERSION 0.1.45 LANGUAGES CXX)
+project(strata VERSION 0.1.45.3 LANGUAGES CXX)
# EXPERIMENTAL: the Intel Arc engine, the SYCL port in sycl/ (PR #423; icpx + oneMKL, docs/INTEL_ARC.md). It is its
# own project that takes the unported sources from src/; with this on, nothing below is configured.
option(STRATA_ENABLE_SYCL "EXPERIMENTAL: build the Intel Arc (SYCL) engine from sycl/ - docs/INTEL_ARC.md" OFF)
diff --git a/apps/desktop/src-tauri/tauri.conf.json b/apps/desktop/src-tauri/tauri.conf.json
index c762d7369..8508eb942 100644
--- a/apps/desktop/src-tauri/tauri.conf.json
+++ b/apps/desktop/src-tauri/tauri.conf.json
@@ -63,7 +63,7 @@
},
"plugins": {
"updater": {
- "pubkey": "REPLACE-WITH-THE-OWNERS-TAURI-UPDATER-PUBLIC-KEY",
+ "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEI2QjA5OTk5MDU1MjFGNUUKUldSZUgxSUZtWm13dHNGRU40N2xOUjdZZGpvcGl0NTB2WGxnS3VTc2RlakpSbnBxUkxndHNFY0oK",
"endpoints": [
"https://github.com/Niko1221/Strata/releases/latest/download/latest.json"
],
diff --git a/apps/host/package-lock.json b/apps/host/package-lock.json
index 899efda6f..d3aa5df36 100644
--- a/apps/host/package-lock.json
+++ b/apps/host/package-lock.json
@@ -1,12 +1,12 @@
{
"name": "strata",
- "version": "0.1.0",
+ "version": "0.2.0-beta",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "strata",
- "version": "0.1.0",
+ "version": "0.2.0-beta",
"dependencies": {
"html-to-image": "^1.11.13",
"pdfjs-dist": "^6.4.299",
diff --git a/apps/host/package.json b/apps/host/package.json
index 0b8d4c53a..7d73c8656 100644
--- a/apps/host/package.json
+++ b/apps/host/package.json
@@ -1,7 +1,7 @@
{
"name": "strata",
"private": true,
- "version": "0.1.0",
+ "version": "0.2.0-beta",
"type": "module",
"description": "Strata \u2014 local AI, tuned to one model. Web shell + engine host.",
"scripts": {
diff --git a/metal/CMakeLists.txt b/metal/CMakeLists.txt
index 3e1b38c0d..3274dfc63 100644
--- a/metal/CMakeLists.txt
+++ b/metal/CMakeLists.txt
@@ -108,7 +108,7 @@ file(GLOB STRATA_METAL_ENGINE_SOURCES CONFIGURE_DEPENDS ${CMAKE_CURRENT_SOURCE_D
add_library(strata_metal_host STATIC ${STRATA_METAL_HOST_SOURCES})
target_include_directories(strata_metal_host PUBLIC ${STRATA_ROOT}/include ${S}/core ${STRATA_ROOT}/third_party/ggml
${STRATA_GGML_DIR}/ggml/include ${STRATA_GGML_DIR}/ggml/src ${STRATA_GGML_DIR}/ggml/src/ggml-cpu)
-target_compile_definitions(strata_metal_host PUBLIC STRATA_NATIVE_EXPERTS=1 STRATA_VERSION="0.1.45-metal")
+target_compile_definitions(strata_metal_host PUBLIC STRATA_NATIVE_EXPERTS=1 STRATA_VERSION="0.1.45.3-metal")
target_compile_options(strata_metal_host PRIVATE -Wno-unused-parameter -Wno-deprecated-declarations)
target_link_libraries(strata_metal_host PUBLIC strata_gpu_metal ggml-cpu ggml-base)
diff --git a/packaging/UPDATES.md b/packaging/UPDATES.md
index d938a11cd..76a11198b 100644
--- a/packaging/UPDATES.md
+++ b/packaging/UPDATES.md
@@ -98,13 +98,16 @@ On an offline machine, outside any git checkout:
npx tauri signer generate -w D:\strata-keys\tauri-updater.key # asks for a password; prints the public key
Back both up (a lost feed key means every installed PC needs a build with a new key; a lost Tauri key means the same for the app).
-Then, in git, once, in the commit that ships the first signed release:
+Then, in git, once, in the commit that ships the first signed release (done for 0.2.0, key id 5d1bc23abbeffd0d):
* the `keys` entry from `feed-key.pub.json` into `strata_control/update_keys.json`;
* the Tauri public key into `apps/desktop/src-tauri/tauri.conf.json` (`plugins.updater.pubkey`) and into `update_keys.json` as `app_minisign_public`
(the Terminal verifies the app installer with it).
-Until then `update_keys.json` is empty and every feed is refused with "this build trusts no update key": a build with no key cannot install anything.
+Only release keys live in `update_keys.json`. A tester or local-test key is never added there: it is passed with `STRATA_UPDATE_TRUSTED_KEYS`
+(a file of extra public keys; `packaging/make_local_feed.py` writes one as `test-trust.json`), so private tester builds keep working
+without their key being part of a release build. A build whose `update_keys.json` is empty (a source checkout from before the keys) refuses every
+feed with "this build trusts no update key".
A key rotation is a release that carries both public keys; the old private key signs that release, the new one signs the next.
## Releasing (when the owner says go)
@@ -116,8 +119,12 @@ A key rotation is a release that carries both public keys; the old private key s
python packaging/feed_tool.py build-feed --out RELEASE --sequence N --key <feed-key.json> --engine RELEASE/engine --control RELEASE/control --app-json <tauri latest.json>
python packaging/feed_tool.py verify-feed RELEASE --pub <feed-key.pub.json>
-Where the feed is hosted (GitHub release assets, a static host, ...) is the owner's decision; the default address in
-`strata_cli/update_cmd.py` is a placeholder until then, and nothing in this tree uploads anything.
+The feed is hosted as the files of a GitHub release of `Niko1221/Strata`. The built-in address is
+`https://github.com/Niko1221/Strata/releases/latest/download` (`strata_cli/update_cmd.py` `DEFAULT_FEED` adds `/strata-feed.json`; `install.sh`
+and `install.ps1` use the folder). GitHub assets are flat, so build the packages with `--url-prefix ""` and upload every file of the release folder
+as an asset: `strata-feed.json`, `strata-feed.json.sig`, `install-manifest.txt`, `install.sh`, `install.ps1`, the engine and Control archives and the
+app installer with `latest.json` (the Tauri updater endpoint). `STRATA_FEED` (installers) and `--feed` / `STRATA_UPDATE_FEED` (`strata update`) override the
+address. Nothing in this tree uploads anything.
## Testing locally
diff --git a/packaging/install.ps1 b/packaging/install.ps1
index 84afa615c..ef63eec9a 100644
--- a/packaging/install.ps1
+++ b/packaging/install.ps1
@@ -1,6 +1,6 @@
# Strata Terminal: one-line installer for Windows (PowerShell 5.1 or newer).
#
-# irm <feed>/install.ps1 | iex
+# irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex
#
# What it does, in order (and nothing else):
# 1. finds out which computer this is (Windows, processor, graphics card);
@@ -13,8 +13,8 @@
# The engine and the model are not part of this: `strata launch` fetches the engine for your graphics card the first time you choose
# a model, from the same release folder, signed.
#
-# <feed> is where the release folder is hosted; until that is decided this script has no address built in. Set $env:STRATA_FEED to the
-# folder (a URL) to use it, for example a local test feed: $env:STRATA_FEED='http://127.0.0.1:8099'; irm http://127.0.0.1:8099/install.ps1 | iex
+# <feed> is where the release folder is hosted: GitHub Releases of Niko1221/Strata (the "latest" release's files), built in as the default.
+# Set $env:STRATA_FEED to another folder (a URL) to use that instead, for example a local test feed: $env:STRATA_FEED='http://127.0.0.1:8099'; irm http://127.0.0.1:8099/install.ps1 | iex
# Optional: $env:STRATA_DATA_DIR (default %LOCALAPPDATA%\Strata), $env:STRATA_INSTALL_TEST_TRUST='1' (a test feed: trust only its
# test-trust.json for step 4), $env:STRATA_NO_PATH='1' (do not change the user PATH).
& { # a child scope: `irm | iex` runs in the caller's scope, and this script's variables must not overwrite the caller's
@@ -23,9 +23,9 @@ $ProgressPreference = 'SilentlyContinue'
function Die([string]$msg) { [Console]::Error.WriteLine("strata installer: $msg"); throw "strata installer stopped" }
-$feed = if ($env:STRATA_FEED) { $env:STRATA_FEED } else { '__FEED__' }
+$feed = if ($env:STRATA_FEED) { $env:STRATA_FEED } else { 'https://github.com/Niko1221/Strata/releases/latest/download' }
$feed = $feed.TrimEnd('/')
-if ($feed -eq ('__FE' + 'ED__') -or -not $feed) {
+if (-not $feed) {
Die 'this installer does not know where the Strata release folder is. Set $env:STRATA_FEED to its address and run it again, for example: $env:STRATA_FEED=''https://example.org/strata'''
}
if ([Environment]::OSVersion.Platform -ne 'Win32NT') { Die 'this is the Windows installer; on Linux or macOS use install.sh.' }
diff --git a/packaging/install.sh b/packaging/install.sh
index 2a17250f5..3b582dc33 100644
--- a/packaging/install.sh
+++ b/packaging/install.sh
@@ -1,7 +1,7 @@
#!/bin/sh
# Strata Terminal: one-line installer for Linux and macOS.
#
-# curl -fsSL <feed>/install.sh | sh
+# curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh | sh
#
# What it does, in order (and nothing else):
# 1. finds out which computer this is (system, processor, graphics card) so it can fetch the right archive;
@@ -14,14 +14,14 @@
# The engine (the part that talks to your graphics card) and the model are NOT part of this: `strata launch` fetches the engine for
# your card the first time you choose a model, from the same release folder, signed.
#
-# <feed> is where the release folder is hosted; until that is decided this script has no address built in. Set STRATA_FEED to the
-# folder (a URL) to use it, for example a local test feed: STRATA_FEED=http://127.0.0.1:8099 sh install.sh
+# <feed> is where the release folder is hosted: GitHub Releases of Niko1221/Strata (the "latest" release's files), built in as the default.
+# Set STRATA_FEED to another folder (a URL) to use that instead, for example a local test feed: STRATA_FEED=http://127.0.0.1:8099 sh install.sh
#
# Settings (all optional): STRATA_FEED, STRATA_DATA_DIR (default ~/.local/share/strata), STRATA_BIN_DIR (default ~/.local/bin),
# STRATA_INSTALL_TEST_TRUST=1 (a test feed: also fetch <feed>/test-trust.json and trust only that key for the check in step 4).
set -eu
-FEED="${STRATA_FEED:-__FEED__}"
+FEED="${STRATA_FEED:-https://github.com/Niko1221/Strata/releases/latest/download}"
FEED="${FEED%/}"
DATA_DIR="${STRATA_DATA_DIR:-${XDG_DATA_HOME:-$HOME/.local/share}/strata}"
BIN_DIR="${STRATA_BIN_DIR:-$HOME/.local/bin}"
@@ -29,9 +29,7 @@ BIN_DIR="${STRATA_BIN_DIR:-$HOME/.local/bin}"
say() { printf '%s\n' "$*"; }
die() { printf 'strata installer: %s\n' "$*" >&2; exit 1; }
-case "$FEED" in
- "__FE""ED__"|"") die "this installer does not know where the Strata release folder is. Set STRATA_FEED to its address and run it again, for example: STRATA_FEED=https://example.org/strata sh install.sh" ;;
-esac
+[ -n "$FEED" ] || die "this installer does not know where the Strata release folder is. Set STRATA_FEED to its address and run it again, for example: STRATA_FEED=https://example.org/strata sh install.sh"
# ---- tools
if command -v curl >/dev/null 2>&1; then
diff --git a/packaging/make_local_feed.py b/packaging/make_local_feed.py
index 870d324ed..d6d79c457 100644
--- a/packaging/make_local_feed.py
+++ b/packaging/make_local_feed.py
@@ -30,6 +30,7 @@ import zipfile
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
+RELEASE_FEED = "https://github.com/Niko1221/Strata/releases/latest/download" # the address built into install.sh / install.ps1; a local feed bakes its own in its place
sys.path.insert(0, str(ROOT / "packaging"))
sys.path.insert(0, str(ROOT))
@@ -99,7 +100,7 @@ def main(argv=None) -> int:
(out / "install-manifest.txt").write_text("\n".join(manifest_lines) + "\n", encoding="utf-8")
base = a.url.rstrip("/")
for name in ("install.sh", "install.ps1"):
- text = (ROOT / "packaging" / name).read_text(encoding="utf-8").replace("__FEED__", base)
+ text = (ROOT / "packaging" / name).read_text(encoding="utf-8").replace(RELEASE_FEED, base)
(out / name).write_text(text, encoding="utf-8", newline="\n" if name.endswith(".sh") else None)
(out / "test-trust.json").write_text((keys / "feed-key.pub.json").read_text(encoding="utf-8"), encoding="utf-8")
print(f"feed written to {out}\n serve it: python -m http.server {base.rsplit(':', 1)[-1]} --bind 127.0.0.1 --directory {out}\n"
diff --git a/strata_cli/update_cmd.py b/strata_cli/update_cmd.py
index 953b4dd9f..4bdb089c0 100644
--- a/strata_cli/update_cmd.py
+++ b/strata_cli/update_cmd.py
@@ -20,8 +20,8 @@ import sys
import threading
from pathlib import Path
-#: Where the feed is read when nothing else is set. It is the owner's decision where the feed is hosted; until the public key
-#: is shipped in update_keys.json no feed can be verified, so this default cannot install anything by itself.
+#: Where the feed is read when nothing else is set: the files of the latest GitHub release of Niko1221/Strata (the same folder the
+#: one-line installers use). Only a feed signed with a key in update_keys.json (or STRATA_UPDATE_TRUSTED_KEYS) is accepted.
DEFAULT_FEED = "https://github.com/Niko1221/Strata/releases/latest/download/strata-feed.json"
ENV_FEED = "STRATA_UPDATE_FEED"
ENV_APP_VERSION = "STRATA_APP_VERSION"
diff --git a/strata_control/update_keys.json b/strata_control/update_keys.json
index c6e1b771f..006e30e59 100644
--- a/strata_control/update_keys.json
+++ b/strata_control/update_keys.json
@@ -1,4 +1,11 @@
{
"schema_version": 1,
- "keys": []
+ "keys": [
+ {
+ "alg": "ed25519",
+ "key_id": "5d1bc23abbeffd0d",
+ "public": "KjnXZB0T1r3dmBNot8h+c4rTicRtllg1LH9fUlTw4ZY="
+ }
+ ],
+ "app_minisign_public": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEI2QjA5OTk5MDU1MjFGNUUKUldSZUgxSUZtWm13dHNGRU40N2xOUjdZZGpvcGl0NTB2WGxnS3VTc2RlakpSbnBxUkxndHNFY0oK"
}
diff --git a/tests/terminal/test_engine_manifest.py b/tests/terminal/test_engine_manifest.py
index 209e40aac..2e388b499 100644
--- a/tests/terminal/test_engine_manifest.py
+++ b/tests/terminal/test_engine_manifest.py
@@ -12,7 +12,7 @@ import unittest
from pathlib import Path
from unittest import mock
-from strata_control import components, engine_component as ec
+from strata_control import components, engine_component as ec, signing
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / "packaging"))
@@ -188,6 +188,9 @@ class Start(unittest.TestCase):
self.folder = package_engine.build(make_source(self.root / "src"), "cuda", "0.1.45", HERE, self.out,
archs=("sm_86",), min_driver={"nvidia": "580.65"}, build_id="b1")
self.addCleanup(ec.register_signature_verifier, None)
+ patch = mock.patch.object(signing, "BUILTIN_KEYS", self.root / "no-shipped-keys.json") # a build with no shipped key; the real file: test_release_keys
+ patch.start()
+ self.addCleanup(patch.stop)
def start(self, **kw):
with mock.patch.object(ec, "cuda_archs_present", return_value=kw.pop("cards", ["sm_86"])), \
diff --git a/tests/terminal/test_launch_install.py b/tests/terminal/test_launch_install.py
index 13dfd7121..888a0f265 100644
--- a/tests/terminal/test_launch_install.py
+++ b/tests/terminal/test_launch_install.py
@@ -18,6 +18,8 @@ from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT / "packaging"))
+sys.path.insert(0, str(ROOT))
+import make_local_feed as mlf # noqa: E402
class Scripts(unittest.TestCase):
@@ -28,13 +30,15 @@ class Scripts(unittest.TestCase):
r = subprocess.run([sh, "-n", str(ROOT / "packaging" / "install.sh")], capture_output=True, text=True)
self.assertEqual(r.returncode, 0, r.stderr)
text = (ROOT / "packaging" / "install.sh").read_text(encoding="utf-8")
- self.assertEqual(text.count("__FEED__"), 1) # the baked address replaces only the default; the guard survives
+ self.assertNotIn("__FEED__", text) # no placeholder: the GitHub Releases address is the built-in default
+ self.assertIn(":-" + mlf.RELEASE_FEED + "}", text) # the default a local feed bakes its own address over
self.assertIn("Installed. Run: ", text)
self.assertNotIn("\r", text)
def test_install_ps1_parses_and_guard(self):
text = (ROOT / "packaging" / "install.ps1").read_text(encoding="utf-8")
- self.assertEqual(text.count("__FEED__"), 1)
+ self.assertNotIn("__FEED__", text)
+ self.assertIn("else { '" + mlf.RELEASE_FEED + "' }", text)
self.assertIn("Installed. Run: strata launch", text)
ps = shutil.which("powershell") or shutil.which("pwsh")
if not ps:
@@ -44,14 +48,12 @@ class Scripts(unittest.TestCase):
r = subprocess.run([ps, "-NoProfile", "-Command", cmd], capture_output=True, text=True)
self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
- def test_a_script_without_an_address_says_what_to_do(self):
- sh = shutil.which("sh") or shutil.which("bash")
- if not sh or os.name == "nt":
- self.skipTest("POSIX sh only")
- env = {k: v for k, v in os.environ.items() if k != "STRATA_FEED"}
- r = subprocess.run([sh, str(ROOT / "packaging" / "install.sh")], capture_output=True, text=True, env=env)
- self.assertNotEqual(r.returncode, 0)
- self.assertIn("Set STRATA_FEED", r.stderr)
+ def test_the_built_in_address_is_the_default_feed(self):
+ """install.sh / install.ps1 and `strata update` use the same GitHub Releases folder; STRATA_FEED stays an override."""
+ from strata_cli import update_cmd
+ self.assertEqual(update_cmd.DEFAULT_FEED, mlf.RELEASE_FEED + "/strata-feed.json")
+ self.assertIn(":-" + mlf.RELEASE_FEED + "}", (ROOT / "packaging" / "install.sh").read_text(encoding="utf-8"))
+ self.assertIn("$env:STRATA_FEED", (ROOT / "packaging" / "install.ps1").read_text(encoding="utf-8"))
class Feed(unittest.TestCase):
@@ -89,7 +91,7 @@ class Feed(unittest.TestCase):
self.assertEqual(control.stat().st_size, int(line[4]))
sh_text = (feed / "install.sh").read_text()
self.assertIn("http://127.0.0.1:1", sh_text)
- self.assertIn('"__FE""ED__"', sh_text) # the guard was not rewritten
+ self.assertNotIn(mlf.RELEASE_FEED, sh_text) # the GitHub address was replaced everywhere by the local one
self.assertIn("Installed. Run:", (feed / "install.ps1").read_text())
doc = json.loads((feed / "strata-feed.json").read_text())
self.assertEqual(doc["control"]["packages"][0]["sha256"], line[3])
diff --git a/tests/terminal/test_release_keys.py b/tests/terminal/test_release_keys.py
new file mode 100644
index 000000000..8c87afa28
--- /dev/null
+++ b/tests/terminal/test_release_keys.py
@@ -0,0 +1,49 @@
+"""The keys shipped with a release build (strata_control/update_keys.json): the release feed key and the Tauri app key are there,
+the tester / local-test keys are not (they come with STRATA_UPDATE_TRUSTED_KEYS), and a feed is verified against them."""
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+from strata_control import feed as feedmod, signing
+from tests.terminal import update_fixture as fx
+
+ROOT = Path(__file__).resolve().parents[2]
+RELEASE_KEY_ID = "5d1bc23abbeffd0d"
+TAURI_CONF = ROOT / "apps" / "desktop" / "src-tauri" / "tauri.conf.json"
+
+
+class ShippedKeys(unittest.TestCase):
+ def test_the_release_feed_key_is_shipped_and_valid(self):
+ with mock.patch.dict(os.environ, {signing.ENV_EXTRA_KEYS: ""}):
+ keys = signing.load_trusted_keys()
+ self.assertEqual(list(keys), [RELEASE_KEY_ID]) # only the release key: no tester or local-test key in a release build
+ self.assertEqual(signing.key_id_of(keys[RELEASE_KEY_ID]), RELEASE_KEY_ID)
+
+ def test_the_app_key_is_the_one_in_the_tauri_config(self):
+ shipped = json.loads((ROOT / "strata_control" / "update_keys.json").read_text(encoding="utf-8-sig"))["app_minisign_public"]
+ conf = json.loads(TAURI_CONF.read_text(encoding="utf-8-sig"))["plugins"]["updater"]["pubkey"]
+ self.assertEqual(shipped, conf)
+ key_id, public = signing.minisign_public(shipped) # parses as a real Ed25519 minisign key, not the placeholder
+ self.assertEqual(len(public), 32)
+ self.assertEqual(signing.app_public_key if False else shipped, conf)
+
+ def test_a_feed_signed_by_another_key_is_refused_and_a_tester_key_works_through_the_override(self):
+ other = fx.make_key()
+ with tempfile.TemporaryDirectory() as t:
+ extra = Path(t) / "tester-keys.json"
+ extra.write_text(json.dumps({"keys": [signing.public_part(other)]}))
+ with mock.patch.dict(os.environ, {signing.ENV_EXTRA_KEYS: ""}):
+ self.assertNotIn(other["key_id"], signing.load_trusted_keys()) # a tester key is not part of a release build
+ with mock.patch.dict(os.environ, {signing.ENV_EXTRA_KEYS: str(extra)}):
+ keys = signing.load_trusted_keys()
+ self.assertIn(other["key_id"], keys) # private tester builds: their key via the override
+ self.assertIn(RELEASE_KEY_ID, keys) # ... beside the release key
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/tests/terminal/test_updater.py b/tests/terminal/test_updater.py
index 67d93edaf..12025b2ff 100644
--- a/tests/terminal/test_updater.py
+++ b/tests/terminal/test_updater.py
@@ -49,8 +49,20 @@ class UpdaterCase(unittest.TestCase):
patch.start()
self.addCleanup(patch.stop)
self.addCleanup(ec.register_signature_verifier, None)
+ # the tests sign with throwaway keys that they hand over explicitly: the release key shipped in update_keys.json is not in play here
+ # (ReleaseKeys below checks the shipped file itself)
+ patch = mock.patch.object(signing, "BUILTIN_KEYS", self.root / "no-shipped-keys.json")
+ patch.start()
+ self.addCleanup(patch.stop)
self.key = fx.make_key()
self.trusted = fx.trusted_of(self.key)
+ # the engine a test start runs is a child process: it reads the shipped release key too, so the test key is passed the way a
+ # tester build passes its key
+ self.test_keys = self.root / "test-trust.json"
+ self.test_keys.write_text(json.dumps({"keys": [signing.public_part(self.key)]}))
+ patch = mock.patch.dict(os.environ, {"STRATA_UPDATE_TRUSTED_KEYS": str(self.test_keys)})
+ patch.start()
+ self.addCleanup(patch.stop)
self.hardware = {"platform": PLATFORM, "backend": "cuda", "runtime": None, "nvidia_driver": "610.47",
"cuda_archs": ["sm_86"], "gfx": []}
self.models = self.root / "models"