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++
#!/usr/bin/env bash
# Sign the Strata Mac app (dmg or .app) and, optionally, the Mac Terminal archive with the owner's Developer ID, then notarise
# them with Apple, so macOS opens them without the "damaged" / "unidentified developer" warning.
#
# bash sign-and-notarize.sh <Strata-tester-mac.dmg | Strata.app> [--terminal <Strata-Terminal-Mac.zip>] [--engine <engine-folder.tar.gz>] [--updater-archive] [--out DIR] [--dry-run]
# bash sign-and-notarize.sh --terminal <Strata-Terminal-Mac.zip> # the Terminal archive alone
# bash sign-and-notarize.sh --terminal <Terminal.tar.gz> --engine <strata-dsv41-...-unsigned-folder.tar.gz> # both in one run
#
# This script runs on the OWNER'S Mac, where the certificate "Developer ID Application: Niko Veit (79LR4R7RSC)" is in the Keychain and the
# notarytool keychain profile "strata-notary" exists. It never asks for, reads or stores a password or a key: codesign and notarytool
# take them from the Keychain themselves. Nothing is uploaded except what notarytool sends to Apple's notary service.
#
# Environment overrides (the defaults are the owner's values):
# SIGN_ID the signing identity (default: Developer ID Application: Niko Veit (79LR4R7RSC))
# NOTARY_PROFILE the notarytool keychain profile (default: strata-notary)
# TMPDIR where the work folder is made (needs about 4 x the size of the input free)
#
# --dry-run: no Apple account is touched. Signs with the ad-hoc identity (SIGN_ID=-), skips notarytool/stapler/spctl-accept, and is
# how this script is tested on a Mac that has no certificate. An ad-hoc signature has no Team ID, so in a dry run the hardened-runtime
# "library validation" cannot be satisfied by libraries signed with the same identity; the dry run therefore adds
# com.apple.security.cs.disable-library-validation to node and python ONLY so that the smoke tests can run. A real run never does.
#
# What it does, in order (each step prints OK or FAIL; the first FAIL stops the run and the summary says which):
# 1. copies the .app out of the dmg into a temporary folder;
# 2. signs every nested Mach-O inside-out (deepest first): hardened runtime, secure timestamp, entitlements only where needed;
# 3. rewrites the SHA-256 and size of every engine file it signed in the engine package's engine-component.json (Control refuses an
# engine whose files do not match that manifest), then signs the .app itself;
# 4. codesign --verify --deep --strict, spctl -a -vvv;
# 5. smoke tests of the SIGNED copy (the app's own --self-test, node loading every native addon, python imports, the engine's --version,
# and Control's own engine manifest check), so a signing mistake shows up here and not on a tester's Mac;
# 6. notarises the .app, staples it, rebuilds the dmg (same layout as apps/desktop/scripts/make-dmg.sh), signs the dmg, notarises the dmg,
# staples it, spctl -a -t open --context context:primary-signature -vv;
# 7. Terminal archive: signs every Mach-O inside, re-zips, notarises the zip (a zip cannot be stapled: see the note at the end).
# 7b. --engine FOLDER.tar.gz (the DeepSeek engine package of the Mac, a tar of one folder: strata-dsv41, its metal/ sources and
# engine-component.json): signs every Mach-O in it like the engine inside the app (hardened runtime, timestamp, no entitlements),
# writes the signed files' SHA-256 and size into engine-component.json, codesign --verify --strict on each, checks that the signed
# program starts, notarises a zip of the folder, and packs it again as strata-dsv41-<version>-<platform>-<backend>-folder.tar.gz (modes
# kept). Sign the folder with the feed key AFTER this step, on the PC: signing changes the program, so the manifest changes with it.
# 8. --updater-archive (opt-in, needs the app input): packs the signed, notarised, stapled .app into Strata.app.tar.gz, the file Tauri's in-app
# updater downloads on a Mac (Strata.app at the root of the archive), and checks it by unpacking it again. The archive is NOT signed with the
# Tauri updater key here: this script never touches that key. Sign it on the PC (npx tauri signer sign) and put it in the update file with
# packaging/feed_tool.py set-app-platform (see packaging/UPDATES.md). Any Strata.app.tar.gz / .sig that `tauri build` made earlier holds the
# UNSIGNED app and must not be published.
set -u
set -o pipefail
SIGN_ID="${SIGN_ID:-Developer ID Application: Niko Veit (79LR4R7RSC)}"
NOTARY_PROFILE="${NOTARY_PROFILE:-strata-notary}"
HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ENT_NODE_SRC="$HERE/entitlements-node.plist"
INPUT=""; TERMINAL=""; ENGINE=""; OUT=""; DRY=0; KEEP=0; SIGN_NESTED=0; UPDATER_ARCHIVE=0
WORK=""
LOG=""
declare -a RESULTS=()
declare -a MOUNTS=()
declare -a FINAL=()
NOTARY_ID=""
usage() {
sed -n '2,/^set -u$/p' "${BASH_SOURCE[0]}" | sed '$d' | sed 's/^# \{0,1\}//'
exit "${1:-2}"
}
while [ $# -gt 0 ]; do
case "$1" in
--terminal) [ $# -ge 2 ] || usage; TERMINAL="$2"; shift 2 ;;
--engine) [ $# -ge 2 ] || usage; ENGINE="$2"; shift 2 ;;
--out) [ $# -ge 2 ] || usage; OUT="$2"; shift 2 ;;
--dry-run) DRY=1; shift ;;
--keep-work) KEEP=1; shift ;;
--sign-nested) SIGN_NESTED=1; shift ;;
--updater-archive) UPDATER_ARCHIVE=1; shift ;;
-h|--help) usage 0 ;;
-*) echo "unknown option: $1" >&2; usage ;;
*) if [ -z "$INPUT" ]; then INPUT="$1"; shift; else echo "unexpected argument: $1" >&2; usage; fi ;;
esac
done
[ -n "$INPUT" ] || [ -n "$TERMINAL" ] || [ -n "$ENGINE" ] || usage
if [ "$UPDATER_ARCHIVE" -eq 1 ] && [ -z "$INPUT" ]; then echo "--updater-archive needs the app (a .dmg or .app) as the input" >&2; usage; fi
# ----------------------------------------------------------------------------------------------------------------- output helpers
say() { printf '%s\n' "$*"; [ -z "$LOG" ] || printf '%s\n' "$*" >>"$LOG"; }
rec() { RESULTS+=("$1|$2|${3:-}"); say " [$1] $2${3:+: $3}"; }
summary() {
local rc=$1 line st name detail f sum
say ""
say "================================ SUMMARY ================================"
if [ "${#RESULTS[@]}" -gt 0 ]; then
for line in "${RESULTS[@]}"; do
st="${line%%|*}"; line="${line#*|}"; name="${line%%|*}"; detail="${line#*|}"
printf ' %-5s %s%s\n' "$st" "$name" "${detail:+ ($detail)}"
done
fi
if [ "${#FINAL[@]}" -gt 0 ]; then
say ""
say "Final files:"
for f in "${FINAL[@]}"; do
sum="$(shasum -a 256 "$f" | awk '{print $1}')"
say " $f"
say " sha256 $sum"
[ -z "$OUT" ] || printf '%s %s\n' "$sum" "$(basename "$f")" >>"$OUT/SHA256SUMS.txt"
done
fi
say ""
if [ "$rc" -eq 0 ]; then
if [ "$DRY" -eq 1 ]; then say "RESULT: DRY RUN finished. Nothing was sent to Apple; these files are ad-hoc signed and are NOT for release."
else say "RESULT: all steps OK."; fi
else
say "RESULT: FAILED. Read the FAIL line above. Full log: ${LOG:-none}"
fi
if [ -n "$TERMINAL" ] || [ -n "$ENGINE" ]; then
say ""
say "Note on the Terminal zip and the engine folder: Apple cannot staple a ticket to bare command-line programs in a zip, so the zip carries no ticket. Notarisation is"
say "still recorded at Apple by the programs' hashes, and macOS checks that online the first time a quarantined (browser-downloaded) copy is opened."
say "Offline, the first open of such a copy needs a connection. Installs done with 'curl | sh' are not quarantined at all, so this mainly helps zips"
say "downloaded in a browser. The zip's sha256 changed: any feed or checksum list that names the old zip must be rebuilt from this one."
fi
}
finish() { summary "$1"; exit "$1"; }
fail() { rec FAIL "$1" "${2:-}"; finish 1; }
# shellcheck disable=SC2329 # run by the EXIT trap below
cleanup() {
local m
if [ "${#MOUNTS[@]}" -gt 0 ]; then
for m in "${MOUNTS[@]}"; do hdiutil detach "$m" -force >/dev/null 2>&1 || true; done
fi
if [ -n "$WORK" ] && [ -d "$WORK" ]; then
if [ "$KEEP" -eq 1 ]; then echo "work folder kept: $WORK" >&2; else rm -rf "$WORK"; fi
fi
}
trap cleanup EXIT
trap 'echo "interrupted" >&2; exit 130' INT TERM HUP
# run a command, appending all its output to the log; on failure show the last lines of it
logged() {
local tmp rc
tmp="$(mktemp "${WORK:-${TMPBASE:-/tmp}}/cmd.XXXXXX")"
"$@" >"$tmp" 2>&1; rc=$?
cat "$tmp" >>"${LOG:-/dev/null}"
[ "$rc" -eq 0 ] || { tail -n 12 "$tmp" | sed 's/^/ /' >&2; }
rm -f "$tmp"
return "$rc"
}
# run a command with a time limit (macOS has no timeout(1)); 124 = timed out
run_timeout() {
local secs=$1 i=0 pid
shift
"$@" &
pid=$!
while kill -0 "$pid" 2>/dev/null; do
if [ "$i" -ge $((secs * 2)) ]; then
pkill -P "$pid" 2>/dev/null; kill "$pid" 2>/dev/null; sleep 1; kill -9 "$pid" 2>/dev/null
wait "$pid" 2>/dev/null
return 124
fi
sleep 0.5; i=$((i + 1))
done
wait "$pid"
}
# ----------------------------------------------------------------------------------------------------------------- preflight
[ "$(uname -s)" = Darwin ] || { echo "This script runs on a Mac (it needs codesign, hdiutil, notarytool)." >&2; exit 2; }
for tool in codesign hdiutil ditto shasum file xattr perl PlistBuddy; do
if [ "$tool" = PlistBuddy ]; then [ -x /usr/libexec/PlistBuddy ] || { echo "missing /usr/libexec/PlistBuddy" >&2; exit 2; }
else command -v "$tool" >/dev/null 2>&1 || { echo "missing tool: $tool" >&2; exit 2; }; fi
done
if [ "$DRY" -eq 1 ]; then
SIGN_ID="-"
else
command -v xcrun >/dev/null 2>&1 || { echo "missing xcrun (install the Xcode command line tools: xcode-select --install)" >&2; exit 2; }
fi
if [ "$DRY" -eq 1 ]; then :
elif [ "$SIGN_ID" = "-" ]; then
echo "SIGN_ID=- is an ad-hoc signature, which Apple cannot notarise. Add --dry-run to test with it." >&2; exit 2
fi
[ -z "$INPUT" ] || [ -e "$INPUT" ] || { echo "not found: $INPUT" >&2; exit 2; }
[ -z "$TERMINAL" ] || [ -f "$TERMINAL" ] || { echo "not found: $TERMINAL" >&2; exit 2; }
[ -z "$ENGINE" ] || [ -f "$ENGINE" ] || { echo "not found: $ENGINE" >&2; exit 2; }
case "$ENGINE" in ""|*.tar.gz|*.tgz) ;; *) echo "--engine takes the engine folder as a .tar.gz: $ENGINE" >&2; exit 2 ;; esac
if [ -z "$OUT" ]; then
first="${INPUT:-${TERMINAL:-$ENGINE}}"
OUT="$(cd "$(dirname "$first")" && pwd)/signed"
fi
mkdir -p "$OUT" || { echo "cannot create $OUT" >&2; exit 2; }
OUT="$(cd "$OUT" && pwd)"
TMPBASE="${TMPDIR:-/tmp}"; TMPBASE="${TMPBASE%/}" # macOS TMPDIR ends in "/": a "//" in the path broke the app self-test
WORK="$(mktemp -d "$TMPBASE/strata-sign.XXXXXX")" || { echo "cannot make a work folder" >&2; exit 2; }
LOG="$OUT/sign-and-notarize.log"
: >"$LOG"
: >"$OUT/SHA256SUMS.txt"
say "Strata sign-and-notarize, $(date '+%Y-%m-%d %H:%M:%S')"
say " identity : $SIGN_ID"
if [ "$DRY" -eq 1 ]; then say " mode : DRY RUN (ad-hoc, no notarisation)"; else say " profile : $NOTARY_PROFILE"; fi
say " work : $WORK"
say " output : $OUT"
say ""
need_kb=0
for f in "$INPUT" "$TERMINAL" "$ENGINE"; do
[ -n "$f" ] || continue
kb="$(du -sk "$f" | awk '{print $1}')"; need_kb=$((need_kb + kb * 5))
done
free_kb="$(df -k "$WORK" | awk 'NR==2 {print $4}')"
if [ "$free_kb" -lt "$need_kb" ]; then
fail "free space" "about $((need_kb / 1048576)) GB needed in $WORK, $((free_kb / 1048576)) GB free; set TMPDIR to a bigger disk"
fi
if [ "$DRY" -eq 0 ]; then
if ! security find-identity -v -p codesigning 2>/dev/null | grep -qF "\"$SIGN_ID\""; then
fail "signing identity" "\"$SIGN_ID\" is not in your Keychain (security find-identity -v -p codesigning lists what is)"
fi
if ! xcrun notarytool history --keychain-profile "$NOTARY_PROFILE" >/dev/null 2>&1; then
fail "notary profile" "profile \"$NOTARY_PROFILE\" does not work (create it once: xcrun notarytool store-credentials $NOTARY_PROFILE ...), or there is no internet"
fi
rec OK "preflight" "identity and notary profile found"
else
rec OK "preflight" "dry run, ad-hoc identity"
fi
# ----------------------------------------------------------------------------------------------------------------- entitlements
# Every entitlement is a hole in the hardened runtime, so there are as few as work (each one was tested; see entitlements-node.plist).
# node: com.apple.security.cs.allow-jit (V8 writes machine code into MAP_JIT memory; without it node dies at start with
# "Failed to reserve virtual memory for CodeRange"). Nothing else: WebAssembly, regexp JIT and the native addons run with just this.
# python, the engine, the app shell, rg, spawn-helper, every .dylib/.so/.node: none. (Python's ctypes callbacks and numpy run without any;
# Metal compiles the engine's kernel sources through the system compiler service, which needs nothing from the engine process.)
# disable-library-validation: NOT used. It would only be needed if a hardened program loaded a library signed by somebody else; every
# library in these bundles is re-signed here with the one identity, so they share a Team ID. (Dry run only: see the header.)
ENT_NODE="$ENT_NODE_SRC"
ENT_DLV=""
if [ "$DRY" -eq 1 ]; then
ENT_DLV="$WORK/dlv.plist"
ENT_NODE="$WORK/node-dryrun.plist"
cp "$ENT_NODE_SRC" "$ENT_NODE"
/usr/libexec/PlistBuddy -c "Add :com.apple.security.cs.disable-library-validation bool true" "$ENT_NODE" >/dev/null
printf '<?xml version="1.0" encoding="UTF-8"?>\n<plist version="1.0"><dict><key>com.apple.security.cs.disable-library-validation</key><true/></dict></plist>\n' >"$ENT_DLV"
fi
[ -f "$ENT_NODE_SRC" ] || fail "entitlements" "missing $ENT_NODE_SRC (keep it next to this script)"
ent_for() {
case "$(basename "$1")" in
node) printf '%s' "$ENT_NODE" ;;
python|python3|python3.[0-9]*) printf '%s' "$ENT_DLV" ;; # empty in a real run
*) printf '' ;;
esac
}
# ----------------------------------------------------------------------------------------------------------------- signing helpers
# Every Mach-O (programs, .dylib, .so, .node, universal binaries), deepest path first. Object files cannot be signed and are skipped.
find_macho() {
find "$1" -type f -print0 2>/dev/null | xargs -0 file --mime-type 2>/dev/null \
| sed -n 's/:[[:space:]]*application\/x-mach-binary$//p' | sed 's/ (for architecture [^)]*)$//' | sort -u \
| while IFS= read -r f; do
case "$(file -b "$f")" in *object*|*"core file"*) continue ;; esac
printf '%s\n' "$f"
done \
| awk '{ n = gsub("/", "/"); print n "\t" $0 }' | sort -rn | cut -f2-
}
codesign_item() { # path [extra codesign args...]
local f=$1 ent try=1 rc=1
shift
local -a args=(--force --sign "$SIGN_ID" --options runtime)
if [ "$SIGN_ID" = "-" ]; then args+=(--timestamp=none); else args+=(--timestamp); fi
ent="$(ent_for "$f")"
[ -z "$ent" ] || args+=(--entitlements "$ent")
while [ "$try" -le 3 ]; do
logged codesign "${args[@]}" "$@" "$f" && { rc=0; break; }
say " (attempt $try of 3 failed; the timestamp server is sometimes slow)"
try=$((try + 1)); sleep 3
done
return "$rc"
}
codesign_plain() { # a disk image: signature and secure timestamp, no hardened-runtime flag (that flag is for programs)
local f=$1 try=1
local -a args=(--force --sign "$SIGN_ID")
if [ "$SIGN_ID" = "-" ]; then args+=(--timestamp=none); else args+=(--timestamp); fi
while [ "$try" -le 3 ]; do
logged codesign "${args[@]}" "$f" && return 0
try=$((try + 1)); sleep 3
done
return 1
}
sign_tree() { # folder label: all Mach-O inside-out, then nested bundles
local dir=$1 label=$2 f n=0 bad=0 d
while IFS= read -r f; do
[ -n "$f" ] || continue
if codesign_item "$f"; then n=$((n + 1)); else say " could not sign: $f"; bad=$((bad + 1)); fi
done < <(find_macho "$dir")
[ "$bad" -eq 0 ] || fail "sign $label" "$bad file(s) could not be signed (see the log)"
# nested bundles (frameworks, helper apps, XPC services), deepest first; there are none in today's app
while IFS= read -r d; do
[ -n "$d" ] || continue
[ "$d" != "$dir" ] || continue
if [ -f "$d/Contents/Info.plist" ] || [ -f "$d/Resources/Info.plist" ] || [ -d "$d/Versions" ]; then
codesign_item "$d" || fail "sign $label" "nested bundle $d"
fi
done < <(find "$dir" -type d \( -name '*.app' -o -name '*.framework' -o -name '*.xpc' -o -name '*.appex' \) 2>/dev/null | awk '{ n = gsub("/", "/"); print n "\t" $0 }' | sort -rn | cut -f2-)
rec OK "sign $label" "$n Mach-O file(s) signed"
}
# The engine packages inside the bundle carry engine-component.json with the SHA-256 and size of every file; Control checks them before it
# starts an engine. Signing changes the engine binary, so the manifest must be brought up to date, or the signed app would refuse its own engine.
update_engine_manifests() { # folder label
local dir=$1 label=$2 m out rc n=0
while IFS= read -r m; do
[ -n "$m" ] || continue
out="$(perl -MJSON::PP -MDigest::SHA -e '
my ($file) = @ARGV; local $/; open my $fh, "<", $file or die "cannot read $file\n"; my $raw = <$fh>; close $fh;
$raw =~ s/^\xEF\xBB\xBF//;
my $json = JSON::PP->new->utf8->canonical->pretty; my $d = $json->decode($raw);
(my $dir = $file) =~ s{/[^/]+$}{};
if (defined $d->{signature}) { print "signed-manifest\n"; exit 3; }
my $changed = 0;
for my $e (@{ $d->{files} || [] }) {
my $p = "$dir/$e->{path}"; next unless -f $p;
open my $f, "<:raw", $p or die "cannot read $p\n"; my $sha = Digest::SHA->new(256); $sha->addfile($f); close $f;
my $hex = $sha->hexdigest; my $size = -s $p;
if (lc($e->{sha256}) ne $hex or $e->{bytes} != $size) { $e->{sha256} = $hex; $e->{bytes} = $size + 0; $changed++; }
}
if ($changed) { open my $o, ">", $file or die "cannot write $file\n"; print $o $json->encode($d); close $o; }
print "$changed\n";
' "$m" 2>&1)"; rc=$?
if [ "$rc" -eq 3 ]; then
fail "engine manifest $label" "$m carries a release signature; changing a file would break it. Sign this engine package at its source, or re-sign its manifest with the release key"
elif [ "$rc" -ne 0 ]; then
fail "engine manifest $label" "$m: $out"
fi
n=$((n + 1)); say " $m: $out entry(ies) updated"
done < <(find "$dir" -name engine-component.json -type f 2>/dev/null)
rec OK "engine manifests $label" "$n manifest(s) checked"
}
verify_signed() { # path label
local p=$1 label=$2
if logged codesign --verify --deep --strict --verbose=2 "$p"; then rec OK "codesign --verify --deep --strict $label"
else fail "codesign --verify --deep --strict $label" "see the log"; fi
}
# notarytool submit --wait; sets NOTARY_ID. On anything but Accepted, fetches Apple's log and fails.
notarize() { # file label
local f=$1 label=$2 out status
out="$WORK/notary-$label.txt"
say " sending $(basename "$f") to Apple ($(du -h "$f" | awk '{print $1}')); this waits for the result, usually 2 to 15 minutes ..."
xcrun notarytool submit "$f" --keychain-profile "$NOTARY_PROFILE" --wait --timeout 60m >"$out" 2>&1
cat "$out" >>"$LOG"
NOTARY_ID="$(awk '/^ *id:/ {print $2; exit}' "$out")"
status="$(awk '/^ *status:/ {s = $2} END {print s}' "$out")"
if [ "$status" = "Accepted" ]; then
rec OK "notarise $label" "Accepted, submission $NOTARY_ID"
return 0
fi
if [ -n "$NOTARY_ID" ]; then
xcrun notarytool log --keychain-profile "$NOTARY_PROFILE" "$NOTARY_ID" "$OUT/notary-log-$label.json" >>"$LOG" 2>&1
say ""
say "---- Apple's notarisation log for $label (submission $NOTARY_ID), also saved to $OUT/notary-log-$label.json ----"
cat "$OUT/notary-log-$label.json" 2>/dev/null | tee -a "$LOG"
say "-------------------------------------------------------------------------------"
else
tail -n 15 "$out" | sed 's/^/ /'
fi
fail "notarise $label" "status: ${status:-no answer from notarytool}"
}
# a finished file goes to the output folder only when every step for it has passed, so a half-done file is never mistaken for a release
deliver() { # file original
local f=$1 orig=$2 dest
dest="$OUT/$(basename "$f")"
if [ -e "$dest" ] && [ "$dest" -ef "$orig" ]; then fail "write the result" "$dest is the input file itself; choose another --out folder"; fi
cp -p "$f" "$dest" || fail "write the result" "cannot write $dest"
FINAL+=("$dest")
}
zip_dir() { # src_dir out.zip (keeps symlinks and permissions, no AppleDouble clutter)
ditto -c -k --norsrc --noextattr --noqtn --noacl --keepParent "$1" "$2"
}
# ----------------------------------------------------------------------------------------------------------------- smoke tests (signed copy)
smoke_app() { # app
local app=$1 res="$1/Contents/Resources" home="$WORK/smokehome" rep="$WORK/self-test.json" node py ctl rc f fails=0 out r engines=0
mkdir -p "$home"
node="$res/node/node"; ctl="$res/control"; py="$ctl/python/bin/python3"
export PYTHONDONTWRITEBYTECODE=1 PYTHONNOUSERSITE=1 # a smoke test must not write into the sealed bundle
# 1. the app's own headless self-test: private node, host, UI, Control on the bundled python
run_timeout 150 env HOME="$home" "$app/Contents/MacOS/strata-desktop" --self-test="$rep" >"$WORK/selftest.out" 2>&1; rc=$?
cat "$WORK/selftest.out" >>"$LOG"
if [ "$rc" -eq 0 ]; then rec OK "smoke: app --self-test (host, UI, Control)"
else
grep -E '"(name|ok|detail)"' "$rep" 2>/dev/null | paste - - - | grep 'false' | sed 's/^/ /'
fail "smoke: app --self-test" "exit $rc; the signed app cannot start its host (see the log)"
fi
# 2. every native addon loads in the signed, hardened node (library validation, JIT)
if [ -x "$node" ]; then
out="$WORK/addons.txt"; : >"$out"
while IFS= read -r f; do
case "$(file -b "$f")" in *arm64*) ;; *) continue ;; esac
r="$("$node" -e 'try { process.dlopen({ exports: {} }, process.argv[1]); console.log("OK"); } catch (e) { console.log("ERR " + String(e.message).split("\n")[0]); }' "$f" 2>&1 | head -n 1)"
[ -n "$r" ] || r="ERR killed by the system (code signature)"
printf '%s: %s\n' "$f" "$r" >>"$out"
done < <(find "$res" -name '*.node' -type f 2>/dev/null)
cat "$out" >>"$LOG"
if grep -qiE 'code signature|team id|library validation|not valid for use|killed' "$out"; then
grep -iE 'code signature|team id|library validation|not valid for use' "$out" | sed 's/^/ /'
fail "smoke: node loads its native addons" "library validation refuses an addon (a library with a different signature)"
fi
if ! "$node" -e 'WebAssembly.instantiate(new Uint8Array([0,97,115,109,1,0,0,0])).then(()=>{let s=0;for(let i=0;i<2e6;i++)s+=i%7;if(!/a+b/.test("aab"))process.exit(3);console.log("jit ok")})' >>"$LOG" 2>&1; then
fail "smoke: node JIT and WebAssembly" "the hardened node cannot run JIT code (entitlement missing?)"
fi
rec OK "smoke: node JIT, WebAssembly and native addons" "$(grep -c ': OK' "$out") addon(s) loaded"
else
rec SKIP "smoke: node" "no bundled node"
fi
# 3. Control's python imports its compiled modules
if [ -x "$py" ]; then
if (cd "$ctl" && env HOME="$home" "$py" -c '
import ctypes, importlib, sys
for m in ("numpy", "PIL.Image", "psutil", "yaml", "regex", "charset_normalizer", "markupsafe", "ssl", "sqlite3", "zlib", "lzma", "hashlib"):
try: importlib.import_module(m)
except ModuleNotFoundError: pass
cb = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_void_p)(lambda a, b: 0)
arr = (ctypes.c_int * 4)(4, 3, 2, 1); ctypes.CDLL(None).qsort(arr, 4, 4, cb)
print("python ok", sys.version.split()[0])' >>"$LOG" 2>&1); then rec OK "smoke: bundled python imports and ctypes callbacks"
else fail "smoke: bundled python" "an import or a ctypes callback failed under the hardened runtime (see the log)"; fi
fi
# 4. every bundled engine starts, and Control accepts its manifest (hashes of the signed files)
while IFS= read -r f; do
[ -n "$f" ] || continue
engines=$((engines + 1))
if run_timeout 30 "$f" --version >"$WORK/engine-version.txt" 2>&1; then say " $(head -n 1 "$WORK/engine-version.txt")"; else
cat "$WORK/engine-version.txt" >>"$LOG"; fails=$((fails + 1)); say " engine did not start: $f"
fi
done < <(find "$res/engine-bundle" -mindepth 2 -maxdepth 2 -type f \( -name strata -o -name strata-device -o -name strata-vision \) 2>/dev/null)
[ "$fails" -eq 0 ] || fail "smoke: bundled engine starts" "$fails engine(s) did not start under the hardened runtime"
if [ -x "$py" ] && [ -d "$res/engine-bundle" ]; then
out="$(cd "$ctl" && env HOME="$home" "$py" -c '
import sys, pathlib
from strata_control import engine_component as ec
bad = 0; n = 0
for m in sorted(pathlib.Path(sys.argv[1]).glob("*/engine-component.json")):
n += 1
try:
c = ec.read_manifest(m.parent); ec.verify(c, full=True); print("manifest ok", c.version, c.platform, c.backend)
except Exception as e:
bad += 1; print("MANIFEST PROBLEM", m, type(e).__name__, e)
sys.exit(1 if bad or not n else 0)' "$res/engine-bundle" 2>&1)"; rc=$?
printf '%s\n' "$out" >>"$LOG"
if [ "$rc" -eq 0 ]; then rec OK "smoke: engine manifest matches the signed files (Control's own check)"
else printf '%s\n' "$out" | sed 's/^/ /'; fail "smoke: engine manifest" "Control would refuse the signed engine"; fi
fi
if [ "$engines" -gt 0 ]; then rec OK "smoke: bundled engine --version" "$engines engine(s), no model loaded"; else rec SKIP "smoke: bundled engine" "this app carries no engine"; fi
}
smoke_terminal() { # extracted terminal folder
local root=$1 py f strata home="$WORK/termhome" out
mkdir -p "$home"
export PYTHONDONTWRITEBYTECODE=1 PYTHONNOUSERSITE=1
py="$(find "$root" -maxdepth 4 -path '*/python/bin/python3' \( -type f -o -type l \) 2>/dev/null | head -n 1)"
if [ -n "$py" ]; then
if env HOME="$home" "$py" -c 'import ctypes, ssl, sqlite3, zlib; print("python ok")' >>"$LOG" 2>&1; then rec OK "smoke: terminal python starts"
else fail "smoke: terminal python" "does not start under the hardened runtime"; fi
strata="$(dirname "$py")/../../bin/strata"
if [ -x "$strata" ]; then
if out="$(env HOME="$home" STRATA_NO_ACQUIRE=1 "$strata" --version 2>&1)"; then rec OK "smoke: strata --version" "$(printf '%s' "$out" | head -n 1)"
else printf '%s\n' "$out" | tail -n 5 | sed 's/^/ /'; fail "smoke: strata --version" "the Terminal launcher does not start"; fi
fi
else
rec SKIP "smoke: terminal python" "no bundled python in this archive"
fi
while IFS= read -r f; do
[ -n "$f" ] || continue
run_timeout 30 "$f" --version >>"$LOG" 2>&1 || fail "smoke: engine in the Terminal archive" "$f does not start"
done < <(find "$root" -type f \( -name strata -o -name strata-device -o -name strata-vision \) -perm -u+x 2>/dev/null | while IFS= read -r c; do file "$c" | grep -q 'Mach-O' && printf '%s\n' "$c"; done)
}
# ----------------------------------------------------------------------------------------------------------------- the app
process_app() {
local app_src="" appdir="$WORK/app" app version vol dmg_name zip out_dmg mnt bundle_real
mkdir -p "$appdir"
if [ -d "$INPUT" ] && { [[ "$INPUT" == *.app ]] || [[ "$INPUT" == *.app/ ]]; }; then
app_src="${INPUT%/}"
ditto --norsrc --noextattr --noqtn "$app_src" "$appdir/$(basename "$app_src")" || fail "copy the app" "ditto failed"
app="$appdir/$(basename "$app_src")"
dmg_name="Strata.dmg"
rec OK "copy the app" "from $INPUT"
elif [ -f "$INPUT" ] && [[ "$INPUT" == *.dmg ]]; then
mnt="$WORK/mnt-in"; mkdir -p "$mnt"
logged hdiutil attach -nobrowse -readonly -noautoopen -mountpoint "$mnt" "$INPUT" || fail "open the dmg" "hdiutil attach failed (is it already mounted?)"
MOUNTS+=("$mnt")
app_src="$(find "$mnt" -maxdepth 1 -name '*.app' -type d | head -n 1)"
[ -n "$app_src" ] || fail "open the dmg" "no .app at the top of $INPUT"
ditto --norsrc --noextattr --noqtn "$app_src" "$appdir/$(basename "$app_src")" || fail "copy the app" "ditto failed"
hdiutil detach "$mnt" >/dev/null 2>&1 || hdiutil detach "$mnt" -force >/dev/null 2>&1
app="$appdir/$(basename "$app_src")"
dmg_name="$(basename "$INPUT")"
rec OK "copy the app out of the dmg" "$(basename "$app") ($(du -sh "$app" | awk '{print $1}'))"
else
fail "input" "$INPUT is neither a .dmg nor a .app"
fi
[ -f "$app/Contents/Info.plist" ] || fail "input" "$app has no Contents/Info.plist"
xattr -cr "$app" 2>/dev/null
version="$(/usr/libexec/PlistBuddy -c 'Print :CFBundleShortVersionString' "$app/Contents/Info.plist" 2>/dev/null || echo "")"
sign_tree "$app" "app contents"
update_engine_manifests "$app" "app"
if codesign_item "$app"; then rec OK "sign the .app itself"; else fail "sign the .app itself" "see the log"; fi
verify_signed "$app" "app"
if spctl -a -vvv -t exec "$app" >>"$LOG" 2>&1; then rec OK "spctl -a -vvv app" "accepted"
elif [ "$DRY" -eq 1 ]; then rec INFO "spctl -a -vvv app" "rejected, as expected for an ad-hoc dry run"
else rec INFO "spctl -a -vvv app" "rejected before notarisation (source=Unnotarized Developer ID); it is checked again after stapling"; fi
smoke_app "$app"
verify_signed "$app" "app after the smoke tests (nothing in the sealed bundle changed)"
bundle_real="$app"
if [ "$DRY" -eq 0 ]; then
zip="$WORK/$(basename "$app" .app)-notarize.zip"
zip_dir "$app" "$zip" || fail "zip the app for Apple" "ditto failed"
notarize "$zip" "app"
logged xcrun stapler staple "$app" || fail "staple the app" "stapler failed"
logged xcrun stapler validate "$app" || fail "staple the app" "stapler validate failed"
rec OK "staple the app"
if spctl -a -vvv -t exec "$app" >>"$LOG" 2>&1; then rec OK "spctl -a -vvv app (after notarisation)" "accepted, Notarized Developer ID"
else fail "spctl -a -vvv app (after notarisation)" "Gatekeeper still rejects the stapled app"; fi
rm -f "$zip"
fi
# the dmg, same layout as apps/desktop/scripts/make-dmg.sh: the app, an Applications link, the volume icon, no Finder arrangement
vol="Strata ${version:-app}"
mkdir -p "$WORK/final"
out_dmg="$WORK/final/$dmg_name"
build_dmg "$bundle_real" "$out_dmg" "$vol" || fail "build the dmg" "hdiutil failed (see the log)"
rec OK "build the dmg" "$vol"
codesign_plain "$out_dmg" || fail "sign the dmg" "see the log"
rec OK "sign the dmg"
if [ "$DRY" -eq 0 ]; then
notarize "$out_dmg" "dmg"
logged xcrun stapler staple "$out_dmg" || fail "staple the dmg" "stapler failed"
logged xcrun stapler validate "$out_dmg" || fail "staple the dmg" "stapler validate failed"
rec OK "staple the dmg"
if spctl -a -t open --context context:primary-signature -vv "$out_dmg" >>"$LOG" 2>&1; then rec OK "spctl -a -t open --context context:primary-signature -vv dmg" "accepted"
else fail "spctl on the dmg" "Gatekeeper rejects the notarised dmg"; fi
else
rec INFO "notarise, staple and spctl on the dmg" "skipped in a dry run"
fi
logged hdiutil verify "$out_dmg" || fail "hdiutil verify" "the dmg is damaged"
rec OK "hdiutil verify the dmg"
# the app inside the finished dmg is still the signed one
mnt="$WORK/mnt-out"; mkdir -p "$mnt"
if logged hdiutil attach -nobrowse -readonly -noautoopen -mountpoint "$mnt" "$out_dmg"; then
MOUNTS+=("$mnt")
if logged codesign --verify --deep --strict "$mnt/$(basename "$app")"; then rec OK "the app inside the final dmg verifies"
else hdiutil detach "$mnt" -force >/dev/null 2>&1; fail "the app inside the final dmg" "codesign --verify failed"; fi
hdiutil detach "$mnt" >/dev/null 2>&1 || hdiutil detach "$mnt" -force >/dev/null 2>&1
fi
deliver "$out_dmg" "$INPUT"
if [ "$UPDATER_ARCHIVE" -eq 1 ]; then make_updater_archive "$bundle_real"; fi
}
make_updater_archive() { # the finished (signed, stapled) .app
local app=$1 name chk top out
name="$(basename "$app" .app).app.tar.gz"
out="$WORK/final/$name"
rm -f "$out"
# the layout Tauri's bundler makes and its updater unpacks: the .app folder at the root of a gzip tar, nothing else
# (COPYFILE_DISABLE keeps AppleDouble "._" files out; tar keeps symlinks and permissions)
( cd "$(dirname "$app")" && COPYFILE_DISABLE=1 tar -czf "$out" "$(basename "$app")" ) || fail "pack the updater archive" "tar failed"
chk="$WORK/updater-check"; rm -rf "$chk"; mkdir -p "$chk"
tar -xzf "$out" -C "$chk" || fail "check the updater archive" "tar cannot unpack it"
top="$(ls -A "$chk")"
[ "$top" = "$(basename "$app")" ] || fail "check the updater archive" "the archive root holds '$top', not just $(basename "$app")"
find "$chk" -name '._*' | grep -q . && fail "check the updater archive" "AppleDouble files in the archive"
if logged codesign --verify --deep --strict "$chk/$top"; then rec OK "updater archive: the unpacked app verifies"
else fail "updater archive" "codesign --verify failed on the unpacked app"; fi
if [ "$DRY" -eq 0 ]; then
logged xcrun stapler validate "$chk/$top" || fail "updater archive" "the unpacked app has no valid notarisation ticket"
if spctl -a -vvv -t exec "$chk/$top" >>"$LOG" 2>&1; then rec OK "updater archive: spctl accepts the unpacked app" "Notarized Developer ID"
else fail "updater archive" "Gatekeeper rejects the unpacked app"; fi
else
rec INFO "updater archive: notarisation checks" "skipped in a dry run"
fi
rm -rf "$chk"
rec OK "pack the updater archive" "$name"
deliver "$out" "$INPUT"
}
build_dmg() { # app out.dmg volname
local app=$1 out=$2 vol=$3 rw="$WORK/rw.dmg" mnt="$WORK/mnt-build" kb mb n=0 icon
kb="$(du -sk "$app" | awk '{print $1}')"; mb=$((kb * 13 / 10240 + 80))
rm -f "$rw" "$out"
logged hdiutil create -size "${mb}m" -fs HFS+ -volname "$vol" -type UDIF -ov "$rw" || return 1
mkdir -p "$mnt"
logged hdiutil attach -nobrowse -noautoopen -noverify -mountpoint "$mnt" "$rw" || return 1
MOUNTS+=("$mnt")
ditto --norsrc --noextattr --noqtn "$app" "$mnt/$(basename "$app")" || return 1
ln -s /Applications "$mnt/Applications"
icon="$app/Contents/Resources/Strata.icns"
if [ -f "$icon" ] && command -v SetFile >/dev/null 2>&1; then cp "$icon" "$mnt/.VolumeIcon.icns" && SetFile -a C "$mnt" 2>/dev/null; fi
sync
until hdiutil detach "$mnt" >/dev/null 2>&1; do
n=$((n + 1)); [ "$n" -lt 6 ] || { hdiutil detach "$mnt" -force >/dev/null 2>&1; break; }
sleep 2
done
logged hdiutil convert "$rw" -format UDZO -imagekey zlib-level=9 -o "$out" || return 1
rm -f "$rw"
}
# ----------------------------------------------------------------------------------------------------------------- the Terminal archive
repack_nested() { # extracted root: sign inside .tar.gz/.tgz/.zip archives within the archive (opt-in)
local root=$1 a tmp kind
while IFS= read -r a; do
[ -n "$a" ] || continue
tmp="$WORK/nested.$$.$RANDOM"; mkdir -p "$tmp"
case "$a" in
*.zip) kind=zip; ditto -x -k "$a" "$tmp" ;;
*) kind=tar; tar -xzf "$a" -C "$tmp" ;;
esac || { rm -rf "$tmp"; continue; }
if [ -z "$(find_macho "$tmp" | head -n 1)" ]; then rm -rf "$tmp"; continue; fi
sign_tree "$tmp" "nested $(basename "$a")"
update_engine_manifests "$tmp" "nested $(basename "$a")"
if [ "$kind" = zip ]; then
( cd "$tmp" && ditto -c -k --norsrc --noextattr --noqtn --noacl . "$a" )
else
( cd "$tmp" && COPYFILE_DISABLE=1 tar -czf "$a" . )
fi
rm -rf "$tmp"
say " re-packed $(basename "$a"); a signed feed that pins its hash (strata-feed.json) must be regenerated and re-signed with the release key"
done < <(find "$root" -type f \( -name '*.tar.gz' -o -name '*.tgz' -o -name '*.zip' \) 2>/dev/null)
}
process_terminal() {
local src=$TERMINAL tdir="$WORK/terminal" top stem final notarize_zip name tops nested
name="$(basename "$src")"
mkdir -p "$tdir"
case "$name" in
*.zip) ditto -x -k "$src" "$tdir" || fail "unpack the Terminal archive" "ditto failed" ;;
*.tar.gz|*.tgz) tar -xzf "$src" -C "$tdir" || fail "unpack the Terminal archive" "tar failed" ;;
*) fail "unpack the Terminal archive" "$name is not a .zip or .tar.gz" ;;
esac
rm -rf "$tdir/__MACOSX"
xattr -cr "$tdir" 2>/dev/null
rec OK "unpack the Terminal archive" "$name"
if [ -z "$(find_macho "$tdir" | head -n 1)" ]; then
nested="$(find "$tdir" -type f \( -name '*.tar.gz' -o -name '*.tgz' -o -name '*.zip' \) 2>/dev/null | wc -l | tr -d ' ')"
if [ "$SIGN_NESTED" -eq 0 ] && [ "$nested" -gt 0 ]; then
rec INFO "Terminal archive holds no program directly" "it contains $nested nested archive(s) (a feed folder); use --sign-nested to sign inside them"
fi
fi
sign_tree "$tdir" "terminal"
update_engine_manifests "$tdir" "terminal"
[ "$SIGN_NESTED" -eq 0 ] || repack_nested "$tdir"
if [ "$SIGN_NESTED" -eq 0 ]; then
nested="$(find "$tdir" -type f \( -name '*.tar.gz' -o -name '*.tgz' \) 2>/dev/null | wc -l | tr -d ' ')"
[ "$nested" -eq 0 ] || say " $nested nested .tar.gz archive(s) were left untouched (they are installed by command-line tools and are not quarantined)"
fi
local bad=0 f
while IFS= read -r f; do
[ -n "$f" ] || continue
codesign --verify --strict "$f" >>"$LOG" 2>&1 || { say " bad signature: $f"; bad=$((bad + 1)); }
done < <(find_macho "$tdir")
[ "$bad" -eq 0 ] || fail "codesign --verify --strict (terminal)" "$bad file(s)"
rec OK "codesign --verify --strict (terminal)" "every Mach-O"
smoke_terminal "$tdir"
# pack it again in the format it came in; Apple only takes a zip, so a tar.gz is notarised through a zip of the same files
tops="$(find "$tdir" -mindepth 1 -maxdepth 1 | wc -l | tr -d ' ')"
stem="${name%.tar.gz}"; stem="${stem%.tgz}"; stem="${stem%.zip}"
mkdir -p "$WORK/final"
case "$name" in *.zip) final="$WORK/final/$stem.zip" ;; *) final="$WORK/final/$stem.tar.gz" ;; esac
rm -f "$final"
notarize_zip="$WORK/$stem-notarize.zip"; rm -f "$notarize_zip"
if [ "$tops" -eq 1 ]; then
top="$(find "$tdir" -mindepth 1 -maxdepth 1)"
zip_dir "$top" "$notarize_zip" || fail "pack the Terminal archive" "ditto failed"
case "$name" in *.zip) ;; *) ( cd "$tdir" && COPYFILE_DISABLE=1 tar -czf "$final" "$(basename "$top")" ) || fail "pack the Terminal archive" "tar failed" ;; esac
else
( cd "$tdir" && ditto -c -k --norsrc --noextattr --noqtn --noacl . "$notarize_zip" ) || fail "pack the Terminal archive" "ditto failed"
case "$name" in *.zip) ;; *) ( cd "$tdir" && COPYFILE_DISABLE=1 tar -czf "$final" . ) || fail "pack the Terminal archive" "tar failed" ;; esac
fi
case "$name" in *.zip) cp "$notarize_zip" "$final" ;; esac
rec OK "pack the Terminal archive" "$(basename "$final")"
if [ "$DRY" -eq 0 ]; then
notarize "$notarize_zip" "terminal"
rec INFO "staple the Terminal archive" "not possible for bare programs in a zip; Apple holds the ticket online"
else
rec INFO "notarise the Terminal archive" "skipped in a dry run"
fi
deliver "$final" "$src"
}
# ----------------------------------------------------------------------------------------------------------------- the DeepSeek engine folder
# The Mac DeepSeek engine package (strata-dsv41, its metal/ sources, engine-component.json) as a .tar.gz of ONE folder. The Qwen engine
# gets its Developer ID signature as a nested program of the signed app; this does the same for the DeepSeek one, which Control installs
# from the update feed. Same identity and options as every nested program above; no entitlements (ent_for gives none for strata-dsv41).
process_engine() {
local src=$ENGINE edir="$WORK/engine" name stem top tops final notarize_zip bin f bad=0 n rc
name="$(basename "$src")"
mkdir -p "$edir"
tar -xzf "$src" -C "$edir" || fail "unpack the engine folder" "tar failed"
rm -rf "$edir/__MACOSX"
xattr -cr "$edir" 2>/dev/null
tops="$(find "$edir" -mindepth 1 -maxdepth 1 | wc -l | tr -d ' ')"
[ "$tops" -eq 1 ] || fail "unpack the engine folder" "$name must hold exactly one folder at its top, found $tops entries"
top="$(find "$edir" -mindepth 1 -maxdepth 1)"
[ -d "$top" ] || fail "unpack the engine folder" "$name holds a file at its top, not a folder"
[ -f "$top/engine-component.json" ] || fail "unpack the engine folder" "$(basename "$top") has no engine-component.json (is this an engine package?)"
rec OK "unpack the engine folder" "$name ($(basename "$top"))"
n="$(find_macho "$edir" | wc -l | tr -d ' ')"
[ "$n" -gt 0 ] || fail "engine folder" "no Mach-O program found in $name"
sign_tree "$edir" "DeepSeek engine"
update_engine_manifests "$edir" "DeepSeek engine"
while IFS= read -r f; do
[ -n "$f" ] || continue
codesign --verify --strict "$f" >>"$LOG" 2>&1 || { say " bad signature: $f"; bad=$((bad + 1)); }
done < <(find_macho "$edir")
[ "$bad" -eq 0 ] || fail "codesign --verify --strict (DeepSeek engine)" "$bad file(s)"
rec OK "codesign --verify --strict (DeepSeek engine)" "every Mach-O"
# the signed program starts under the hardened runtime (a signing mistake kills it at once, exit 137); no model is loaded
bin="$(grep -o '"entrypoint"[^,]*' "$top/engine-component.json" 2>/dev/null | sed 's/.*: *"\(.*\)"/\1/' | head -n 1)"
if [ -n "$bin" ] && [ -x "$top/$bin" ]; then
run_timeout 30 "$top/$bin" --help >"$WORK/engine-help.txt" 2>&1; rc=$?
cat "$WORK/engine-help.txt" >>"$LOG"
if [ "$rc" -ge 128 ]; then fail "smoke: DeepSeek engine starts" "$bin was killed (exit $rc) under the hardened runtime"
else rec OK "smoke: DeepSeek engine starts" "$bin, no model loaded"; fi
else
rec SKIP "smoke: DeepSeek engine" "no entrypoint program found in engine-component.json"
fi
# pack again (modes kept, no AppleDouble files); Apple takes a zip, so the notarisation goes through a zip of the same folder
stem="${name%.tar.gz}"; stem="${stem%.tgz}"
case "$stem" in *-unsigned-folder) stem="${stem%-unsigned-folder}-folder" ;; *-folder) ;; *) stem="$stem-signed" ;; esac
mkdir -p "$WORK/final"
final="$WORK/final/$stem.tar.gz"
rm -f "$final"
notarize_zip="$WORK/$stem-notarize.zip"; rm -f "$notarize_zip"
zip_dir "$top" "$notarize_zip" || fail "pack the engine folder" "ditto failed"
( cd "$edir" && COPYFILE_DISABLE=1 tar -czf "$final" "$(basename "$top")" ) || fail "pack the engine folder" "tar failed"
find "$edir" -name '._*' | grep -q . && fail "pack the engine folder" "AppleDouble files in the folder"
rec OK "pack the engine folder" "$(basename "$final")"
if [ "$DRY" -eq 0 ]; then
notarize "$notarize_zip" "engine"
rec INFO "staple the engine folder" "not possible for bare programs; Apple holds the ticket online"
else
rec INFO "notarise the engine folder" "skipped in a dry run"
fi
deliver "$final" "$src"
}
# ----------------------------------------------------------------------------------------------------------------- run
if [ -n "$INPUT" ]; then process_app; fi
if [ -n "$TERMINAL" ]; then process_terminal; fi
if [ -n "$ENGINE" ]; then process_engine; fi
finish 0