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++
import { OFFLINE_MESSAGE, looksOffline, plainUpdateError } from './update-messages.mjs';
/** Read-only release checks. Installing/rolling back needs a managed installer. */
const RELEASES = 'https://api.github.com/repos/Niko1221/Strata/releases?per_page=30';
const RELEASE_PREFIX = 'https://github.com/Niko1221/Strata/releases/';
function versionParts(value) {
const match = /^v?(\d+)\.(\d+)\.(\d+)(?:\+[\w.-]+)?$/.exec(value ?? '');
return match ? match.slice(1).map(Number) : null;
}
function compare(a, b) {
for (let i = 0; i < 3; i++) if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;
return 0;
}
export async function checkUpdates({ appVersion, engineVersion }, fetcher = fetch) {
let strata;
try {
const response = await fetcher(RELEASES, { headers: { accept: 'application/vnd.github+json' }, signal: AbortSignal.timeout(10000) });
if (!response.ok) throw new Error(response.status === 403 || response.status === 429 ? 'The release service is busy. Try again later.' : 'Could not reach the Strata release feed. Try again.');
const releases = await response.json();
if (!Array.isArray(releases)) throw new Error('The release service returned an invalid response.');
const candidates = releases.filter(r => !r.draft && !r.prerelease && versionParts(r.tag_name));
candidates.sort((a, b) => compare(versionParts(b.tag_name), versionParts(a.tag_name)));
const latest = candidates[0];
const installed = versionParts(appVersion);
if (!latest) strata = { status: 'no-releases', message: 'No stable Strata release is published in this feed yet.' };
else if (!installed) strata = { status: 'unavailable', message: 'This installation has no comparable version number.' };
else {
const newer = compare(versionParts(latest.tag_name), installed) > 0;
// Release content is untrusted. Only link back to the known repository.
const releaseUrl = typeof latest.html_url === 'string' && latest.html_url.startsWith(RELEASE_PREFIX) ? latest.html_url : undefined;
strata = { status: newer ? 'available' : 'current', latestVersion: latest.tag_name, releaseUrl, message: newer ? `Strata ${latest.tag_name} is available.` : 'Strata is up to date.' };
}
} catch (error) {
strata = { status: 'error', message: looksOffline(error) ? OFFLINE_MESSAGE : error.name === 'TimeoutError' ? 'The release check timed out. Try again.' : error.message ?? 'Could not check for updates.' };
}
return {
checkedAt: new Date().toISOString(),
strata: { installedVersion: appVersion, ...strata, canInstall: false },
// The existing binary downloader has no tested-release compatibility feed
// or trustworthy installed build ID. Upstream's latest is not an update verdict.
engine: { installedVersion: engineVersion, status: 'unavailable', canInstall: false, message: 'Engine update checks are not available in this build.' },
};
}
/**
* The packaged app's update check: the signed feed, read by Control (`strata update --check`), plus the shell's own verdict
* on the app. Same result shape as `checkUpdates`, so the Settings screen needs no change. This is the only place the host
* reaches the feed, and only when the user presses "Check for updates".
*/
export async function checkComponentUpdates({ control, appUpdater = null, appVersion = null }) {
const checkedAt = new Date().toISOString();
let report;
try {
report = await control.updateCheck({ appVersion });
} catch (error) {
const plain = plainUpdateError(error, 'Strata');
const message = /update server|aren't available|No internet/.test(plain.headline) ? plain.message : `Couldn't check for updates. Try again in a moment.`;
return { checkedAt, strata: { installedVersion: appVersion ?? control.version ?? null, status: 'error', message, details: plain.details, canInstall: false }, engine: { installedVersion: null, status: 'error', message, details: plain.details, canInstall: false } };
}
const mib = bytes => `${Math.round((bytes ?? 0) / 1_000_000)} MB`; // decimal megabytes, like the Terminal and the release page
const engine = report.engine ?? {};
const installedEngine = engine.installed?.version ?? null;
const offered = engine.offered?.version ?? null;
const engineView = { installedVersion: installedEngine, latestVersion: offered ?? undefined, canInstall: engine.status === 'available' || engine.status === 'install' };
if (engine.status === 'available') Object.assign(engineView, { status: 'available', message: `A new engine is available (${mib(engine.download_bytes)}).` });
else if (engine.status === 'install') Object.assign(engineView, { status: 'available', message: `This PC needs an engine to run models. Press Update engine to download it (${mib(engine.download_bytes)}).` });
else if (engine.status === 'current' || engine.status === 'failed-before' || engine.status === 'skipped') Object.assign(engineView, { status: 'current', message: 'The engine is up to date.', details: engine.note });
else if (engine.status === 'wrong-make') Object.assign(engineView, { status: 'unavailable', message: engine.note ?? 'Nothing was changed: the update was for another make of graphics card.', details: (engine.reasons ?? []).join('\n') || undefined });
else if (engine.status === 'not-in-feed') Object.assign(engineView, { status: 'current', message: 'No engine update is listed right now.' });
else Object.assign(engineView, { status: 'unavailable', message: "There isn't an engine for this PC's graphics card yet.", details: (engine.reasons ?? []).join('\n') || undefined });
const control_ = report.control ?? {};
const app = report.app ?? {};
let appNew = app.status === 'available' ? app.offered : null;
let appNotes = app.notes ?? '';
let appCheckFailed = null; // the shell's own (Tauri) check threw: before this, the Settings check hid it and showed only Control's text
let appCannot = null; // browser mode: the app window's updater is not running, so the app itself cannot be updated from here
if (appUpdater) {
try {
const verdict = await appUpdater.check();
appNew = verdict.available ? verdict.version : null;
appNotes = verdict.notes ?? appNotes;
} catch (error) {
if (error?.code === 'app-update-unavailable' && appUpdater.unavailable) appCannot = appUpdater.unavailable;
else appCheckFailed = String(error?.message ?? error ?? 'The app update check failed.'); // the app's own check did not work: say so, raw text behind Details
}
}
const controlNew = control_.status === 'available' ? control_.offered : null;
const strata = { installedVersion: appVersion ?? control_.installed ?? control.version ?? null, canInstall: !!((appNew && !appCannot) || controlNew) };
const appCheckLine = "Strata couldn't check for a new version of the app itself. Try again later.";
if (appNew || controlNew) Object.assign(strata, { status: 'available', latestVersion: appNew ?? controlNew, message: `A new version of Strata is available.${appNotes ? ` ${appNotes}` : ''}${appNew && appCannot ? ` ${appCannot}` : ''}${appCheckFailed ? ` ${appCheckLine}` : ''}` });
else if (appCheckFailed) Object.assign(strata, { status: 'error', message: appCheckLine });
else Object.assign(strata, { status: 'current', message: 'Strata is up to date.' });
if (appCheckFailed) strata.details = appCheckFailed;
return { checkedAt, feed: report.feed, strata, engine: engineView, serving: report.serving ?? [] };
}
/**
* What the first-run card shows: this PC's graphics card(s), the engine package the signed feed offers for it and how big it is.
* One feed read, nothing downloaded. `status`: offer (a package fits), none (nothing fits; `reasons` say why), offline (the feed could not be
* read), installed (an engine is already here), wrong-make (an engine for another make of card is installed).
*/
export async function engineFirstRun({ control, gpus = [] }) {
const cards = gpus.map(g => ({ name: g.name ?? 'Graphics card', vramGb: g.vramGb ?? null }));
let report;
try {
report = await control.updateCheck({});
} catch (error) {
const plain = plainUpdateError(error, 'Strata');
return { status: looksOffline(error) || /update server|No internet/.test(plain.headline ?? '') ? 'offline' : 'error', gpus: cards, message: plain.message, details: plain.details };
}
const engine = report.engine ?? {};
const hardware = report.hardware ?? {};
const base = { gpus: cards, driver: hardware.nvidia_driver ?? null, backend: hardware.backend ?? null };
if (engine.installed) return { ...base, status: 'installed', installedVersion: engine.installed.version ?? null };
if (engine.status === 'wrong-make') return { ...base, status: 'wrong-make', message: engine.note ?? null, reasons: engine.reasons ?? [] };
if (engine.offered && (engine.status === 'install' || engine.status === 'available')) {
return { ...base, status: 'offer', offer: { version: engine.offered.version, bytes: engine.download_bytes || engine.offered.size || 0, variant: engine.offered.variant ?? '', backend: engine.offered.backend ?? null } };
}
return { ...base, status: 'none', message: engine.note ?? null, reasons: engine.reasons ?? [] };
}