dsh-plugin-local-infer 0.1.2 → 0.1.4

package/packages/providers/lib/engines/strata/strataAdapter.js

@@ -0,0 +1,463 @@
+/**
+ * The Strata engine adapter. StrataAdapter is the Strata engine, three build
+ * modes. `renderLaunch` renders a `docker run` of the ghcr image (docker
+ * mode), a `strata launch` process (binary mode), or a `setup.sh` run with the
+ * model (local mode); `deploy` pulls the image, installs the Terminal, or
+ * git-syncs the checkout and resolves `setup.sh` to an absolute path in it
+ * before spawning (spawn resolves a bare name against PATH, not the cwd);
+ * `healthCheck` polls the health URL; `stop` stops the named container, runs
+ * `strata launch --stop`, or signals the tracked process. The model the
+ * engine serves is the config model (or the engine's own pick when none is
+ * named), and the engine downloads it itself, so the deploy step runs no model
+ * download of its own. When the config names no model, `discoverModel`
+ * queries the running engine's model endpoint through the terminal for the id
+ * it actually loaded (family and size sized to the host), so the registrar
+ * publishes the served model, not a placeholder.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataAdapter
+ */
+import { join } from 'node:path';
+import { EngineAdapter, autoRebuildEnabled } from '../../../../core/lib/index.js';
+import { HEALTH_POLL_DEFAULT_MS, HEALTH_POLL_MAX_ATTEMPTS, auditRun, customArgEnv, customArgFlags, delay, envFromSpecs, flagsFromSpecs, logHealthPoll, nodeLifecycleHost, stopProcessPlan, trackChild, } from "../../adapters.js";
+import { syncEngineForDeploy } from "../../acquire.js";
+import { STRATA_PARAMETERS, strataDefaults, strataModelKey, } from "./strata.js";
+import { strataLinuxSourceLaunch } from "./strataLinux.js";
+import { strataMacOSSourceLaunch } from "./strataMacOS.js";
+import { strataWindowsSourceLaunch } from "./strataWindows.js";
+/**
+ * The Strata docker image the adapter pulls and runs. The image is the
+ * upstream GitHub Container Registry artifact for the newest release's CUDA 13
+ * flavor (NVIDIA RTX 20/30/40/50 series, driver 580 or newer); the README pins
+ * a version tag when updates should only land on purpose.
+ */
+export const STRATA_DOCKER_IMAGE = 'ghcr.io/niko1221/strata:latest-cuda13';
+/**
+ * The one-line install the Strata binary build mode runs: it downloads the
+ * `strata` Terminal from the latest release, checks its SHA-256, unpacks it into
+ * the user's home folder, and puts `strata` on the PATH. Sourced from
+ * docs/AI_SETUP.md step 2 (Linux and Mac; Windows uses the PowerShell twin).
+ */
+export const STRATA_BINARY_INSTALL = 'curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh';
+/**
+ * The source-build wrapper is OS-specific (setup.sh on Linux/Mac,
+ * START-HERE.bat on Windows), so the launch argv comes from the host OS's
+ * launch function. The adapter's renderLaunch reads this map by the hardware
+ * profile's os, keeping the per-OS command in its own OS file.
+ */
+const STRATA_SOURCE_LAUNCH = {
+    linux: strataLinuxSourceLaunch,
+    macos: strataMacOSSourceLaunch,
+    windows: strataWindowsSourceLaunch,
+};
+/**
+ * strataPreReadyState reads the phase the strata process is in from the tail of
+ * its accumulated output. The Terminal downloads the engine and the model files
+ * before it can serve, and prints a progress line for each (Downloading,
+ * Unpacking, Checking the package signature, Getting the model files, ...), so
+ * a tail that carries one of those reads as downloading. A tail past the
+ * download (the engine starting, the API binding) reads as starting. The tail
+ * is the most recent output, so a finished download no longer reads as
+ * downloading even though its progress lines are still in the buffer.
+ */
+export function strataPreReadyState(logs) {
+    const tail = logs.slice(-2000);
+    const downloading = /Downloading|Unpacking|Checking the package signature|Test-starting|Getting the model files|Getting your model ready|Getting the helper packages/i.test(tail);
+    return downloading ? 'downloading' : 'starting';
+}
+/**
+ * strataServedModelId reads the served model id out of a /v1/models answer:
+ * the id of the first entry in the JSON `data` list. The engine names the
+ * model it auto-selected with family and size (qwen3.8-flash-next-iq3_s), so
+ * the registrar can publish the id the engine actually serves. A body that is
+ * not JSON, or carries no usable id (an error page, a truncated answer), reads
+ * as no discovery.
+ */
+export function strataServedModelId(body) {
+    const start = body.indexOf('{');
+    const end = body.lastIndexOf('}');
+    if (start < 0 || end <= start) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(body.slice(start, end + 1));
+        const list = Array.isArray(parsed.data) ? parsed.data : [];
+        for (const item of list) {
+            const id = typeof item === 'object' && item !== null ? item.id : undefined;
+            if (typeof id === 'string' && id !== '') {
+                return id;
+            }
+        }
+    }
+    catch {
+        // A partial or non-JSON answer (an error page, a truncated body) carries
+        // no served id.
+    }
+    return undefined;
+}
+/**
+ * StrataAdapter is the Strata engine, three build modes. `renderLaunch` renders
+ * a `docker run` of the ghcr image (docker mode), a `strata launch` process
+ * (binary mode), or a `setup.sh` run with the model (local mode); `deploy` pulls
+ * the image, installs the Terminal, or git-syncs the checkout and resolves
+ * `setup.sh` to an absolute path in it before spawning (spawn resolves a bare
+ * name against PATH, not the cwd); `healthCheck` polls the health URL; `stop`
+ * stops the named container, runs `strata launch --stop`, or signals the
+ * tracked process. The model the engine serves is the config model (or the
+ * engine's own pick when none is named), and the engine downloads it itself, so
+ * the deploy step runs no model download of its own. When the config names no
+ * model, `discoverModel` queries the running engine's model endpoint through
+ * the terminal for the id it actually loaded (family and size sized to the
+ * host), so the registrar publishes the served model, not a placeholder.
+ */
+export class StrataAdapter extends EngineAdapter {
+    id = 'strata';
+    supports = { docker: true, local: true, binary: true };
+    host;
+    children = new Map();
+    constructor(host = nodeLifecycleHost) {
+        super();
+        this.host = host;
+    }
+    parameters() {
+        return STRATA_PARAMETERS;
+    }
+    modelRef(config) {
+        // Strata serves the model under the name the config names (or the engine
+        // default when none), so the registrar publishes that name and a chat turn
+        // routes to it.
+        const model = strataModelKey(config);
+        return model !== '' ? { id: model, name: model } : { id: 'strata', name: 'Strata' };
+    }
+    async discoverModel(config) {
+        // A config that names a model already routes through modelRef; discovery
+        // answers only for the model the engine auto-selected for the host.
+        if (strataModelKey(config) !== '') {
+            return undefined;
+        }
+        // The terminal query: curl the running engine's model list, capped at a
+        // few seconds so a down engine fails fast rather than parking the
+        // register route. A host without output capture cannot read the answer,
+        // so it discovers nothing and the route falls back to modelRef.
+        const runStream = this.host.runStream;
+        if (runStream === undefined) {
+            return undefined;
+        }
+        const port = this.port(config);
+        const chunks = [];
+        const outcome = await runStream.call(this.host, `curl -fsS --max-time 3 http://127.0.0.1:${port}/v1/models`, (chunk) => {
+            chunks.push(chunk);
+        });
+        if (!outcome.ok) {
+            return undefined;
+        }
+        const id = strataServedModelId(chunks.join(''));
+        return id === undefined ? undefined : { id, name: id };
+    }
+    modelInput(config) {
+        // Strata's models read pictures and the vision control is on by default
+        // (on, gpu, and cpu all enable a vision runner), so only 'off' withholds
+        // the Image input on the DSH model row.
+        return config.vision === 'off' ? ['text'] : ['text', 'image'];
+    }
+    launchSignature(config = {}) {
+        // The docker plan's host process is docker run of the ghcr image, so the
+        // image name is the command-line marker; the binary and source-build plans
+        // run the strata command, so the binary name is the marker.
+        const port = this.port(config);
+        if (this.buildMode(config) === 'docker') {
+            return { binary: STRATA_DOCKER_IMAGE, port };
+        }
+        return { binary: 'strata', port };
+    }
+    renderLaunch(config, _hw) {
+        const port = this.port(config);
+        const model = strataModelKey(config);
+        const modelId = model !== '' ? model : undefined;
+        const customArgs = customArgFlags(config);
+        const mode = this.buildMode(config);
+        if (mode === 'docker') {
+            // The container env is the spec surface's toEnv spellings (FAMILY,
+            // CONTEXT, VISION, ...) plus the card's Custom Arguments, plus the model
+            // the container serves. The model download happens inside the container
+            // on first start into the strata-data volume, so no host download.
+            const env = { ...envFromSpecs(STRATA_PARAMETERS, config), ...customArgEnv(config) };
+            if (model !== '') {
+                env.MODEL = model;
+            }
+            const envFlags = Object.entries(env).flatMap(([key, value]) => ['-e', `${key}=${value}`]);
+            const containerName = `strata-${port}`;
+            return {
+                engineId: this.id,
+                kind: 'docker',
+                argv: [
+                    'docker',
+                    'run',
+                    '-d',
+                    '--name',
+                    containerName,
+                    '--gpus',
+                    'all',
+                    '-p',
+                    `127.0.0.1:${port}:8080`,
+                    '--ulimit',
+                    'memlock=-1:-1',
+                    '--shm-size',
+                    '2g',
+                    '--stop-timeout',
+                    '120',
+                    '-v',
+                    'strata-data:/data',
+                    ...envFlags,
+                    STRATA_DOCKER_IMAGE,
+                    ...customArgs,
+                ],
+                env: {},
+                containerName,
+                ...(modelId !== undefined ? { modelId } : {}),
+                port,
+                healthUrl: `http://127.0.0.1:${port}/health`,
+                os: _hw.os,
+            };
+        }
+        if (mode === 'binary') {
+            // The strata Terminal the install script places on the PATH: a
+            // non-interactive launch that downloads what it needs and serves.
+            const flags = flagsFromSpecs(STRATA_PARAMETERS, config);
+            return {
+                engineId: this.id,
+                kind: 'process',
+                argv: [
+                    'strata',
+                    'launch',
+                    ...(model !== '' ? ['--model', model] : []),
+                    '--yes',
+                    '--no-tui',
+                    '--port',
+                    String(port),
+                    ...flags,
+                    ...customArgs,
+                ],
+                env: {},
+                ...(modelId !== undefined ? { modelId } : {}),
+                port,
+                healthUrl: `http://127.0.0.1:${port}/health`,
+                os: _hw.os,
+            };
+        }
+        // The source build: run the OS wrapper (setup.sh on Linux/Mac,
+        // START-HERE.bat on Windows) with the model. It reuses the engine the Get
+        // step built (the acquisition build step), downloads the named model, and
+        // starts the engine. Running the wrapper (rather than a pre-written
+        // run-<model> start script) is model-aware and self-contained, so the
+        // launch does not depend on the build step having written a script for this
+        // exact model. The deploy step resolves the wrapper to an absolute path in
+        // the checkout before spawning.
+        // The source-build wrapper is OS-specific (setup.sh on Linux/Mac,
+        // START-HERE.bat on Windows), so the argv comes from the host OS's launch
+        // function. The config reads (family, vision, context) are OS-agnostic and
+        // resolve their defaults from the parameter surface, so the defaults have
+        // one home.
+        const { family, vision, context } = strataDefaults(config);
+        const sourceLaunch = STRATA_SOURCE_LAUNCH[_hw.os];
+        return {
+            engineId: this.id,
+            kind: 'process',
+            argv: sourceLaunch({ model, family, vision, context, port, customArgs }),
+            env: {},
+            ...(modelId !== undefined ? { modelId } : {}),
+            port,
+            healthUrl: `http://127.0.0.1:${port}/health`,
+            os: _hw.os,
+        };
+    }
+    async deploy(plan, platform, onProgress, options) {
+        if (plan.kind === 'docker') {
+            // Auto Rebuild off (the card's checkbox): the image pull is skipped and
+            // the already-present image starts. The image pull is the docker build
+            // step: the card's button reads "Building..." for it, and its
+            // `$ <command>` line reaches the launch run's log sink before the child
+            // spawns.
+            if (autoRebuildEnabled(options?.autoRebuild)) {
+                onProgress?.('build');
+                const pull = await auditRun(this.host, `docker pull ${STRATA_DOCKER_IMAGE}`, options?.onLog);
+                if (!pull.ok) {
+                    return { ok: false, detail: `docker pull failed: ${pull.detail ?? 'unknown'}` };
+                }
+            }
+            const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {});
+            trackChild(this.children, this.planKey(plan), handle);
+            return { ok: true, handle };
+        }
+        if (plan.kind === 'process') {
+            const engineDir = platform?.engineDirectory;
+            // The binary plan runs the strata command (on the PATH after the install
+            // script), so its build step is the one-line install. The source-build
+            // plan runs the OS wrapper in the checkout, so its build step is the git
+            // sync plus the engine's own wrapper (the acquisition build steps), and
+            // the launch resolves the wrapper to an absolute path in that checkout.
+            const isBinary = plan.argv?.[0] === 'strata';
+            let buildLogs = '';
+            if (isBinary) {
+                // Auto Rebuild off (the card's checkbox): the install is skipped and
+                // the already-installed strata command starts. The install script
+                // downloads the Terminal: the card's button reads "Downloading..."
+                // for it, and its `$ <command>` line reaches the launch run's log
+                // sink before the child spawns.
+                if (autoRebuildEnabled(options?.autoRebuild)) {
+                    onProgress?.('download');
+                    const install = await auditRun(this.host, STRATA_BINARY_INSTALL, options?.onLog);
+                    if (!install.ok) {
+                        return { ok: false, detail: `strata install failed: ${install.detail ?? 'unknown'}` };
+                    }
+                }
+            }
+            else {
+                // The source build needs the checkout directory to resolve the OS
+                // wrapper; without it the launch cannot find the engine.
+                if (engineDir === undefined) {
+                    return {
+                        ok: false,
+                        detail: 'the source build needs an engine directory (the Get step checkout) to run the OS wrapper',
+                    };
+                }
+                if (autoRebuildEnabled(options?.autoRebuild)) {
+                    // The conditional rebuild fetches the checkout, prices it against the
+                    // remote branch, and rebuilds only when it is behind (or a fresh
+                    // clone). The decision, the build command, and its output are
+                    // captured into buildLogs and threaded to the card's Logs section.
+                    const sync = await syncEngineForDeploy(this.host, {
+                        engineId: this.id,
+                        directory: engineDir,
+                        ...(platform !== undefined ? { platform } : {}),
+                        ...(options !== undefined ? { options } : {}),
+                        // The host OS the build steps pick for: a Windows host reads the
+                        // engine's Windows build steps when the user carries no build-
+                        // command override.
+                        ...(plan.os !== undefined ? { os: plan.os } : {}),
+                        ...(onProgress !== undefined ? { onProgress } : {}),
+                    });
+                    buildLogs = sync.buildLogs;
+                    if (!sync.ok) {
+                        return { ok: false, detail: sync.detail ?? 'unknown', logs: buildLogs };
+                    }
+                }
+            }
+            const withLogs = (result) => buildLogs !== '' ? { ...result, logs: buildLogs } : result;
+            // The source-build plan names the OS wrapper relative to the checkout;
+            // resolve it to an absolute path so spawn finds it (spawn resolves a bare
+            // name against PATH, not the cwd). The binary plan's strata is on the
+            // PATH, so it spawns as-is.
+            const argv = plan.argv ?? [];
+            const spawnArgv = !isBinary && engineDir !== undefined
+                ? [join(engineDir, argv[0] ?? 'setup.sh'), ...argv.slice(1)]
+                : argv;
+            const handle = this.host.spawn(spawnArgv, plan.env ?? {}, engineDir);
+            trackChild(this.children, this.planKey(plan), handle);
+            return withLogs({ ok: true, handle });
+        }
+        // A compose plan is a no-op for Strata.
+        return { ok: true };
+    }
+    async healthCheck(plan, options) {
+        // The Strata Terminal downloads its engine and the model files before it
+        // can serve, so the health endpoint is not up for a long time (the model
+        // download can be tens of gigabytes). A plain poll times out and reads the
+        // start as broken, so this poll reads the tracked process's output and
+        // reports the start phase: a 200 is ready, a process that ended before
+        // readiness is failed, and a process still fetching its files after the
+        // attempt cap is downloading (in progress, not a failure) so the card
+        // re-polls instead of showing a broken launch. The shared logHealthPoll
+        // wrap carries the URL-query rule (one `> GET` line ahead of the settled
+        // verdict, retries silent).
+        return logHealthPoll(options?.onLog, plan.healthUrl, async () => {
+            const pollMs = options?.pollMs ?? HEALTH_POLL_DEFAULT_MS;
+            const maxAttempts = options?.maxAttempts ?? HEALTH_POLL_MAX_ATTEMPTS;
+            // The tracked handle is read before the loop: trackChild drops the map
+            // entry when the child ends, so a late read would miss the exit state
+            // the early-exit check needs.
+            const handle = this.children.get(this.planKey(plan));
+            let last = { status: 0, ok: false };
+            let lastPreReady = null;
+            for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                // The state read runs before the fetch: a child that settled (a crash,
+                // a pkill, or a spawn failure) will never report 200, so the poll
+                // ends here with a failed result instead of the full attempt cap.
+                if (handle?.hasExited?.() === true) {
+                    return {
+                        healthy: false,
+                        status: last.status,
+                        state: 'failed',
+                        detail: 'the engine process exited before it reported ready',
+                    };
+                }
+                last = await this.host.fetch(plan.healthUrl);
+                if (last.status === 200) {
+                    return { healthy: true, status: 200, state: 'ready' };
+                }
+                // A running tracked process reports its start phase from its output. A
+                // missing handle (no deploy tracked one, or the process already ended)
+                // falls through to the plain poll: the health URL stays down, so the
+                // loop times out and reads the start as failed.
+                if (handle !== undefined) {
+                    lastPreReady = strataPreReadyState(handle.logs ?? '');
+                }
+                if (pollMs > 0 && attempt < maxAttempts) {
+                    await delay(pollMs);
+                }
+            }
+            // The engine did not report ready within the attempt cap. If it was still
+            // downloading its files, read the start as in progress (downloading): the
+            // download is not a broken launch, and the card re-polls until the engine
+            // reports ready. If the download was done and the engine was starting,
+            // read the start as failed (a stuck start timed out).
+            if (lastPreReady === 'downloading') {
+                return {
+                    healthy: false,
+                    status: last.status,
+                    state: 'downloading',
+                    detail: 'the engine is still downloading its model files',
+                };
+            }
+            return {
+                healthy: false,
+                status: last.status,
+                state: 'failed',
+                detail: `health check did not return 200 within ${maxAttempts} attempts`,
+            };
+        });
+    }
+    async stop(plan, log) {
+        if (plan.kind === 'docker' && plan.containerName !== undefined) {
+            await auditRun(this.host, `docker stop ${plan.containerName}`, log);
+        }
+        // The binary plan stops through the strata command; the source-build plan
+        // has no strata command, so it stops by signalling the tracked process.
+        if (plan.kind === 'process' && plan.argv?.[0] === 'strata') {
+            await auditRun(this.host, 'strata launch --stop', log);
+        }
+        const handle = this.children.get(this.planKey(plan));
+        if (handle !== undefined) {
+            handle.kill();
+            this.children.delete(this.planKey(plan));
+            return;
+        }
+        // No tracked child (an engine a DSH restart re-adopted): signal the pid
+        // the stored launch record stamped on the plan, so the stop reaches a
+        // process this adapter instance did not spawn.
+        await stopProcessPlan(this.host, plan, log);
+    }
+    buildMode(config) {
+        const mode = config.buildMode;
+        if (mode === 'docker' || mode === 'local' || mode === 'binary') {
+            return mode;
+        }
+        // The binary install is the README's one-line path (the one docs/AI_SETUP.md
+        // walks an agent through), so a bare config renders the binary plan.
+        return 'binary';
+    }
+    port(config) {
+        // 8080 is the port the strata launch CLI binds by default, so a bare
+        // config launches on it.
+        return typeof config.port === 'number' ? config.port : 8080;
+    }
+}
+//# sourceMappingURL=strataAdapter.js.map

package/packages/providers/lib/engines/strata/strataArch.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Strata Arch Linux build profile. Arch builds Strata through the shared
+ * Linux route (the engine's own setup.sh), so this profile reuses the shared
+ * Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataArch
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const STRATA_ARCH: EngineOsProfile;
+//# sourceMappingURL=strataArch.d.ts.map

package/packages/providers/lib/engines/strata/strataArch.js

@@ -0,0 +1,9 @@
+/**
+ * The Strata Arch Linux build profile. Arch builds Strata through the shared
+ * Linux route (the engine's own setup.sh), so this profile reuses the shared
+ * Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataArch
+ */
+import { STRATA_LINUX } from "./strataLinux.js";
+export const STRATA_ARCH = STRATA_LINUX;
+//# sourceMappingURL=strataArch.js.map

package/packages/providers/lib/engines/strata/strataDebian.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Strata Debian build profile. Debian builds Strata through the shared
+ * Linux route (the engine's own setup.sh), so this profile reuses the shared
+ * Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataDebian
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const STRATA_DEBIAN: EngineOsProfile;
+//# sourceMappingURL=strataDebian.d.ts.map

package/packages/providers/lib/engines/strata/strataDebian.js

@@ -0,0 +1,9 @@
+/**
+ * The Strata Debian build profile. Debian builds Strata through the shared
+ * Linux route (the engine's own setup.sh), so this profile reuses the shared
+ * Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataDebian
+ */
+import { STRATA_LINUX } from "./strataLinux.js";
+export const STRATA_DEBIAN = STRATA_LINUX;
+//# sourceMappingURL=strataDebian.js.map

package/packages/providers/lib/engines/strata/strataFedora.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The Strata Fedora build profile. Fedora builds Strata through the shared
+ * Linux route (the engine's own setup.sh), so this profile reuses the shared
+ * Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataFedora
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+export declare const STRATA_FEDORA: EngineOsProfile;
+//# sourceMappingURL=strataFedora.d.ts.map

package/packages/providers/lib/engines/strata/strataFedora.js

@@ -0,0 +1,9 @@
+/**
+ * The Strata Fedora build profile. Fedora builds Strata through the shared
+ * Linux route (the engine's own setup.sh), so this profile reuses the shared
+ * Linux profile and carries no build steps of its own.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataFedora
+ */
+import { STRATA_LINUX } from "./strataLinux.js";
+export const STRATA_FEDORA = STRATA_LINUX;
+//# sourceMappingURL=strataFedora.js.map

package/packages/providers/lib/engines/strata/strataLinux.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The Strata shared Linux build profile. Every Linux distro (Arch, Debian,
+ * Fedora) builds Strata through the engine's own setup.sh: the README's
+ * Build-from-source route, which downloads what it needs and installs the
+ * `strata` Terminal to the path. `--yes` takes the recommended answer to every
+ * question and `--no-start` builds and installs without starting the server,
+ * which the adapter's launch step then does. There is no build directory,
+ * because setup.sh installs the binary to the path. The distro profiles reuse
+ * this profile.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataLinux
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+import { type StrataSourceLaunchArgs } from './strata.ts';
+export declare const STRATA_LINUX: EngineOsProfile;
+/**
+ * strataLinuxSourceLaunch renders the source-build launch argv for the Linux
+ * route: the engine's own setup.sh with --yes (unattended) and the resolved
+ * model, family, vision, context, and port. macOS reuses this route.
+ */
+export declare function strataLinuxSourceLaunch(args: StrataSourceLaunchArgs): string[];
+//# sourceMappingURL=strataLinux.d.ts.map

package/packages/providers/lib/engines/strata/strataLinux.js

@@ -0,0 +1,30 @@
+/**
+ * The Strata shared Linux build profile. Every Linux distro (Arch, Debian,
+ * Fedora) builds Strata through the engine's own setup.sh: the README's
+ * Build-from-source route, which downloads what it needs and installs the
+ * `strata` Terminal to the path. `--yes` takes the recommended answer to every
+ * question and `--no-start` builds and installs without starting the server,
+ * which the adapter's launch step then does. There is no build directory,
+ * because setup.sh installs the binary to the path. The distro profiles reuse
+ * this profile.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataLinux
+ */
+import { strataSourceLaunchArgs } from "./strata.js";
+import { SYSTEM_DEPS } from "../../systemDeps.js";
+export const STRATA_LINUX = {
+    buildSteps: ['cd {dir} && ./setup.sh --yes --no-start'],
+    binary: 'strata',
+    // The Strata source build git-clones the repo and runs setup.sh, which
+    // downloads what it needs; the only host deps are git (the clone) and curl
+    // (the model download).
+    deps: [SYSTEM_DEPS.git, SYSTEM_DEPS.curl],
+};
+/**
+ * strataLinuxSourceLaunch renders the source-build launch argv for the Linux
+ * route: the engine's own setup.sh with --yes (unattended) and the resolved
+ * model, family, vision, context, and port. macOS reuses this route.
+ */
+export function strataLinuxSourceLaunch(args) {
+    return strataSourceLaunchArgs('setup.sh', args);
+}
+//# sourceMappingURL=strataLinux.js.map

package/packages/providers/lib/engines/strata/strataMacOS.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The Strata macOS build profile. macOS builds Strata through the engine's own
+ * setup.sh, the same route as Linux (the README's setup walks both), so this
+ * profile reuses the shared Linux build steps; the binary keeps its plain
+ * name (no .exe on macOS).
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataMacOS
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+import type { StrataSourceLaunchArgs } from './strata.ts';
+export declare const STRATA_MACOS: EngineOsProfile;
+/**
+ * strataMacOSSourceLaunch reuses the Linux source-build launch: macOS builds
+ * through the same setup.sh route, so the argv is identical.
+ */
+export declare function strataMacOSSourceLaunch(args: StrataSourceLaunchArgs): string[];
+//# sourceMappingURL=strataMacOS.d.ts.map

package/packages/providers/lib/engines/strata/strataMacOS.js

@@ -0,0 +1,17 @@
+/**
+ * The Strata macOS build profile. macOS builds Strata through the engine's own
+ * setup.sh, the same route as Linux (the README's setup walks both), so this
+ * profile reuses the shared Linux build steps; the binary keeps its plain
+ * name (no .exe on macOS).
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataMacOS
+ */
+import { STRATA_LINUX, strataLinuxSourceLaunch } from "./strataLinux.js";
+export const STRATA_MACOS = STRATA_LINUX;
+/**
+ * strataMacOSSourceLaunch reuses the Linux source-build launch: macOS builds
+ * through the same setup.sh route, so the argv is identical.
+ */
+export function strataMacOSSourceLaunch(args) {
+    return strataLinuxSourceLaunch(args);
+}
+//# sourceMappingURL=strataMacOS.js.map

package/packages/providers/lib/engines/strata/strataWindows.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The Strata Windows build profile. The Windows source route is the engine's
+ * own START-HERE.bat wrapper (docs/SOURCE_INSTALL.md, From source: Windows),
+ * not the Linux setup.sh. `--yes` accepts the recommended answer to every
+ * question, so the step runs unattended. The wrapper acquires a ready-made
+ * engine when one fits the PC, and compiles one when it does not: the
+ * compile needs the Visual Studio 2022 Build Tools with the C++ workload
+ * (the sources are C++20, so VS2019 is too old). When setup cannot find the
+ * toolchain, point STRATA_VCVARS at vcvars64.bat before running. The build
+ * keeps its dependencies and products in the source install and writes the
+ * launch scripts (run-<model>.bat) and run configs (strata-<model>.json)
+ * into the checkout, so the profile carries no build directory. Updates run
+ * through UPDATE.bat.
+ * @module dsh-plugin-local-infer/providers/engines/strata/strataWindows
+ */
+import type { EngineOsProfile } from '../engineOs.ts';
+import { type StrataSourceLaunchArgs } from './strata.ts';
+export declare const STRATA_WINDOWS: EngineOsProfile;
+/**
+ * strataWindowsSourceLaunch renders the source-build launch argv for the
+ * Windows route: the engine's own START-HERE.bat wrapper with --yes
+ * (unattended) and the resolved model, family, vision, context, and port. The
+ * wrapper acquires a ready-made engine when one fits the PC, and compiles one
+ * (the Visual Studio 2022 C++ toolchain) when it does not.
+ */
+export declare function strataWindowsSourceLaunch(args: StrataSourceLaunchArgs): string[];
+//# sourceMappingURL=strataWindows.d.ts.map