dsh-plugin-local-infer 0.1.0 → 0.1.2

package/packages/providers/lib/adapters.js

@@ -5,14 +5,17 @@
  * injectable `LifecycleHost`, so the tests stub the host and never run a real
  * build, docker, or network in CI. The node implementation
  * (`nodeLifecycleHost`) is what the service wires in on a live host.
- * @module @dsh/dsh-plugin-local-infer/providers/adapters
+ * @module dsh-plugin-local-infer/providers/adapters
  */
 import { exec, spawn as nodeSpawn } from 'node:child_process';
 import { basename, dirname, join } from 'node:path';
-import { EngineAdapter } from '../../core/lib/index.js';
+import { EngineAdapter, formatLaunchCommand } from '../../core/lib/index.js';
+import { syncAndRebuildEngine } from "./acquire.js";
 import { NINFER_PARAMETERS } from "./ninfer.js";
 import { HYPERQWEN_PARAMETERS } from "./hyperqwen.js";
 import { LLAMACPP_MODEL_ARTIFACTS, LLAMACPP_PARAMETERS, llamaCppModelKey, } from "./llamacpp.js";
+import { INFERNIX_MODEL_ARTIFACTS, INFERNIX_PARAMETERS, infernixArtifactFor, infernixDraftModelPath, infernixModelKey, } from "./infernix.js";
+export { INFERNIX_MODEL_ARTIFACTS } from "./infernix.js";
 import { STRATA_PARAMETERS } from "./strata.js";
 /**
  * The NInfer model artifacts, keyed by the model registry id. The 27B entry
@@ -169,6 +172,35 @@ export function createNodeLifecycleHost(debug) {
                 });
             });
         },
+        async runStream(command, onOutput) {
+            log?.(`run: ${command}`);
+            return new Promise(resolve => {
+                // No overall timeout: a full CUDA build legitimately runs long, and
+                // the card prices a stalled step with its own output-idle watchdog.
+                const child = nodeSpawn(command, { shell: true, stdio: ['ignore', 'pipe', 'pipe'] });
+                let output = '';
+                const append = (chunk) => {
+                    const text = chunk.toString('utf8');
+                    onOutput(text);
+                    output += text;
+                    if (output.length > 2048) {
+                        output = output.slice(-1024);
+                    }
+                };
+                child.stdout.on('data', append);
+                child.stderr.on('data', append);
+                child.on('error', error => {
+                    resolve({ ok: false, detail: error.message });
+                });
+                child.on('close', code => {
+                    if (code === 0) {
+                        resolve({ ok: true });
+                        return;
+                    }
+                    resolve({ ok: false, detail: `exit ${code}: ${output.trim().slice(-1024)}` });
+                });
+            });
+        },
         spawn(argv, env, cwd) {
             log?.(`spawn: ${argv.join(' ')}${cwd !== undefined ? ` (cwd: ${cwd})` : ''}`);
             const child = nodeSpawn(argv[0] ?? '', argv.slice(1), {
@@ -190,6 +222,51 @@ export function createNodeLifecycleHost(debug) {
             };
             child.stdout?.on('data', append);
             child.stderr?.on('data', append);
+            // An EventEmitter with no 'error' listener turns the event into a thrown
+            // uncaughtException, which takes the DSH host down with it. A spawn that
+            // cannot start (a missing engine binary, an ENOENT) and a stream that
+            // breaks on a crashing child both emit 'error' here, so every path gets
+            // a listener and the failure lands in the logs instead of the crash.
+            child.stdout?.on('error', (error) => {
+                logs = (logs + `stdout error: ${error.message}\n`).slice(-65536);
+            });
+            child.stderr?.on('error', (error) => {
+                logs = (logs + `stderr error: ${error.message}\n`).slice(-65536);
+            });
+            // The one-shot exit contract: 'error' names a child that never ran,
+            // 'exit' carries the code or signal, and 'close' follows once the pipes
+            // drain. The first settled source wins, so the handle's onExit listener
+            // (crash, pkill, or clean stop) fires exactly once with the detail.
+            const listeners = new Set();
+            let exitInfo = null;
+            const settle = (info) => {
+                if (exitInfo !== null)
+                    return;
+                exitInfo = info;
+                for (const listener of listeners) {
+                    try {
+                        listener(info);
+                    }
+                    catch {
+                        // A listener that throws must not re-raise into the child's event
+                        // pipeline and take the host down the way an unlistened 'error' did.
+                    }
+                }
+                listeners.clear();
+            };
+            let exitSignal = null;
+            child.on('error', (error) => {
+                logs = (logs + `spawn error: ${error.message}\n`).slice(-65536);
+                // The error fires before the stdio drains; settle immediately so a
+                // launch of a missing binary reports rather than hangs the watcher.
+                settle({ code: null, signal: null, error: error.message });
+            });
+            child.on('exit', (_code, signal) => {
+                exitSignal = signal;
+            });
+            child.on('close', (code, signal) => {
+                settle({ code, signal: signal ?? exitSignal });
+            });
             return {
                 pid: child.pid ?? -1,
                 kill: () => {
@@ -198,6 +275,16 @@ export function createNodeLifecycleHost(debug) {
                 get logs() {
                     return logs;
                 },
+                onExit: (listener) => {
+                    // A listener registered after the child already ended fires
+                    // immediately, so a late attach (the service wiring after deploy)
+                    // never misses the crash that landed in between.
+                    if (exitInfo !== null) {
+                        listener(exitInfo);
+                        return;
+                    }
+                    listeners.add(listener);
+                },
             };
         },
         async fetch(url) {
@@ -219,6 +306,24 @@ export function createNodeLifecycleHost(debug) {
  * in debug mode.
  */
 export const nodeLifecycleHost = createNodeLifecycleHost();
+/**
+ * trackChild stores a spawned handle in the adapter's children map and ties
+ * the entry's lifetime to the child's: when the child ends (a crash, a pkill,
+ * or the adapter's own stop kill) the entry is dropped, so a later stop never
+ * signals a pid a recycled process has taken over. A handle whose host cannot
+ * watch (onExit absent) stays tracked until stop removes it.
+ */
+function trackChild(children, key, handle) {
+    children.set(key, handle);
+    handle.onExit?.(() => {
+        // Compare identity before deleting: a newer launch that already replaced
+        // this key's entry keeps its handle, and only the ended child's entry
+        // goes.
+        if (children.get(key) === handle) {
+            children.delete(key);
+        }
+    });
+}
 /**
  * pollHealth polls a plan's health URL until a 200 or the attempt cap, the
  * same loop the qwen-ninfer launcher runs. A poll interval of 0 skips the
@@ -368,53 +473,64 @@ export class NInferAdapter extends EngineAdapter {
             healthUrl: `http://127.0.0.1:${port}/health`,
         };
     }
-    async deploy(plan, platform) {
+    async deploy(plan, platform, onProgress, options) {
         if (plan.kind === 'process') {
             const engineDir = platform?.engineDirectory;
-            if (engineDir !== undefined) {
-                const fork = platform?.engineFork;
-                if (fork !== undefined) {
-                    // Mirror the qwen-ninfer launcher: an existing checkout (a .git under
-                    // the engine directory) is updated in place with a best-effort fetch
-                    // and a hard reset to the fork's master, then built as-is; a missing
-                    // checkout is a fresh clone. The fetch is best-effort (a `; true`
-                    // pins the branch to success) so an offline host still builds the
-                    // checkout it has; only a missing checkout that cannot be cloned
-                    // fails the step.
-                    const sync = await this.host.run(`if [ -d ${engineDir}/.git ]; then ` +
-                        `git -C ${engineDir} fetch ${fork} 2>/dev/null && git -C ${engineDir} reset --hard ${fork}/master 2>/dev/null; true; ` +
-                        `else git clone ${fork} ${engineDir}; fi`);
-                    if (!sync.ok) {
-                        return { ok: false, detail: `git sync failed: ${sync.detail ?? 'unknown'}` };
-                    }
+            let buildLogs = '';
+            // Auto Rebuild off (the card's checkbox): the git sync (fetch, rebase,
+            // rebuild) is skipped and the checkout launches as-is.
+            if (engineDir !== undefined && options?.autoRebuild !== false) {
+                // The git sync is the checkout download: the card's button reads
+                // "Downloading..." for it, not "Building...".
+                onProgress?.('download');
+                // 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 syncAndRebuildEngine(this.host, {
+                    engineId: this.id,
+                    directory: engineDir,
+                    ...(platform?.engineFork !== undefined ? { fork: platform.engineFork } : {}),
+                    ...(plan.argv?.[0] !== undefined ? { binary: plan.argv[0] } : {}),
+                    ...(options?.allowRunDeps !== undefined ? { allowRunDeps: options.allowRunDeps } : {}),
+                }, () => { });
+                buildLogs = sync.logs;
+                if (!sync.ok) {
+                    return { ok: false, detail: sync.detail ?? 'unknown', logs: buildLogs };
                 }
-                const build = await this.host.run(`cmake -S ${engineDir} -B ${engineDir}/build -G Ninja -DCMAKE_BUILD_TYPE=Release && ` +
-                    `cmake --build ${engineDir}/build -j`);
-                if (!build.ok) {
-                    return { ok: false, detail: `build failed: ${build.detail ?? 'unknown'}` };
+                // The build step reads as "Building..." only when a build actually
+                // ran (a fresh clone, or a rebase of a checkout that was behind).
+                if (sync.rebuilt) {
+                    onProgress?.('build');
                 }
             }
+            const withLogs = (result) => buildLogs !== '' ? { ...result, logs: buildLogs } : result;
+            onProgress?.('download');
             const download = await this.downloadModel(plan);
             if (!download.ok)
-                return download;
+                return withLogs(download);
             // A chat template the user picked as an HF repo reference (the combo
             // control's known choices) is not a path the engine can read, so the
             // deploy step downloads it into the model directory and rewrites the
             // --chat-template flag to the local file before the spawn.
+            onProgress?.('download');
             const templateResult = await this.resolveChatTemplate(plan);
             if (!templateResult.ok)
-                return templateResult;
+                return withLogs(templateResult);
             const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {}, engineDir);
-            this.children.set(this.planKey(plan), handle);
-            return { ok: true, handle };
+            trackChild(this.children, this.planKey(plan), handle);
+            return withLogs({ ok: true, handle });
         }
         if (plan.kind === 'docker') {
+            // The image pull is the docker build step: the card's button reads
+            // "Building..." for it.
+            onProgress?.('build');
             const pull = await this.host.run(`docker pull ${NINFER_DOCKER_IMAGE}`);
             if (!pull.ok) {
                 return { ok: false, detail: `docker pull failed: ${pull.detail ?? 'unknown'}` };
             }
             const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {});
-            this.children.set(this.planKey(plan), handle);
+            trackChild(this.children, this.planKey(plan), handle);
             return { ok: true, handle };
         }
         // NInfer renders process and docker plans; a compose plan is a no-op.
@@ -547,8 +663,23 @@ export class HyperQwenAdapter extends EngineAdapter {
             healthUrl: `http://127.0.0.1:${port}/health`,
         };
     }
-    async deploy(plan) {
-        const up = await this.host.run(`docker compose -f ${plan.composeFile} --profile ${plan.profile} up --pull always -d`);
+    async deploy(plan, platform, onProgress, _options) {
+        // The card's docker-tag field carries the compose arguments (the profile
+        // the up step selects); the deploy step applies it to the plan so the up
+        // line and the card's Logs section agree.
+        if (platform?.dockerTag !== undefined) {
+            plan.composeArgs = platform.dockerTag;
+        }
+        // The core formatter is the single source of the compose up line: the
+        // card's Logs section prints the same string this run gets.
+        const command = formatLaunchCommand(plan);
+        if (command === undefined) {
+            return { ok: false, detail: 'compose plan carries no command' };
+        }
+        // The compose up is the docker build step: the card's button reads
+        // "Building..." for it.
+        onProgress?.('build');
+        const up = await this.host.run(command);
         if (!up.ok) {
             return { ok: false, detail: `compose up failed: ${up.detail ?? 'unknown'}` };
         }
@@ -558,7 +689,14 @@ export class HyperQwenAdapter extends EngineAdapter {
         return pollHealth(this.host, plan, options);
     }
     async stop(plan) {
-        await this.host.run(`docker compose -f ${plan.composeFile} --profile ${plan.profile} down`);
+        // The down step brings down the containers the up step started, so it
+        // runs the same compose arguments (the profile the up selected); an
+        // absent composeArgs falls back to the engine's default profile.
+        const composeArgs = plan.composeArgs?.split(/\s+/).filter((token) => token !== '');
+        const args = composeArgs !== undefined && composeArgs.length > 0
+            ? composeArgs.join(' ')
+            : `--profile ${plan.profile ?? 'single'}`;
+        await this.host.run(`docker compose -f ${plan.composeFile ?? 'docker-compose.yml'} ${args} down`);
     }
     port(config) {
         return typeof config.port === 'number' ? config.port : 18020;
@@ -687,45 +825,57 @@ export class LlamaCppAdapter extends EngineAdapter {
             healthUrl: `http://127.0.0.1:${port}/health`,
         };
     }
-    async deploy(plan, platform) {
+    async deploy(plan, platform, onProgress, options) {
         if (plan.kind === 'process') {
             const engineDir = platform?.engineDirectory;
-            if (engineDir !== undefined) {
-                const fork = platform?.engineFork;
-                if (fork !== undefined) {
-                    // Mirror the qwen-ninfer launcher: an existing checkout is updated in
-                    // place with a best-effort fetch and a hard reset to the fork's
-                    // master, then built as-is; a missing checkout is a fresh clone. The
-                    // fetch is best-effort (a `; true` pins the branch to success) so an
-                    // offline host still builds the checkout it has.
-                    const sync = await this.host.run(`if [ -d ${engineDir}/.git ]; then ` +
-                        `git -C ${engineDir} fetch ${fork} 2>/dev/null && git -C ${engineDir} reset --hard ${fork}/master 2>/dev/null; true; ` +
-                        `else git clone ${fork} ${engineDir}; fi`);
-                    if (!sync.ok) {
-                        return { ok: false, detail: `git sync failed: ${sync.detail ?? 'unknown'}` };
-                    }
+            let buildLogs = '';
+            // Auto Rebuild off (the card's checkbox): the git sync (fetch, rebase,
+            // rebuild) is skipped and the checkout launches as-is.
+            if (engineDir !== undefined && options?.autoRebuild !== false) {
+                // The git sync is the checkout download: the card's button reads
+                // "Downloading..." for it, not "Building...".
+                onProgress?.('download');
+                // 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 syncAndRebuildEngine(this.host, {
+                    engineId: this.id,
+                    directory: engineDir,
+                    ...(platform?.engineFork !== undefined ? { fork: platform.engineFork } : {}),
+                    ...(plan.argv?.[0] !== undefined ? { binary: plan.argv[0] } : {}),
+                    ...(options?.allowRunDeps !== undefined ? { allowRunDeps: options.allowRunDeps } : {}),
+                }, () => { });
+                buildLogs = sync.logs;
+                if (!sync.ok) {
+                    return { ok: false, detail: sync.detail ?? 'unknown', logs: buildLogs };
                 }
-                const build = await this.host.run(`cmake -S ${engineDir} -B ${engineDir}/build -G Ninja -DCMAKE_BUILD_TYPE=Release && ` +
-                    `cmake --build ${engineDir}/build -j`);
-                if (!build.ok) {
-                    return { ok: false, detail: `build failed: ${build.detail ?? 'unknown'}` };
+                // The build step reads as "Building..." only when a build actually
+                // ran (a fresh clone, or a rebase of a checkout that was behind).
+                if (sync.rebuilt) {
+                    onProgress?.('build');
                 }
             }
+            const withLogs = (result) => buildLogs !== '' ? { ...result, logs: buildLogs } : result;
+            onProgress?.('download');
             const download = await this.downloadModel(plan);
             if (!download.ok)
-                return download;
+                return withLogs(download);
             const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {}, engineDir);
-            this.children.set(this.planKey(plan), handle);
-            return { ok: true };
+            trackChild(this.children, this.planKey(plan), handle);
+            return withLogs({ ok: true, handle });
         }
         if (plan.kind === 'docker') {
+            // The image pull is the docker build step: the card's button reads
+            // "Building..." for it.
+            onProgress?.('build');
             const pull = await this.host.run(`docker pull ${LLAMACPP_DOCKER_IMAGE}`);
             if (!pull.ok) {
                 return { ok: false, detail: `docker pull failed: ${pull.detail ?? 'unknown'}` };
             }
             const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {});
-            this.children.set(this.planKey(plan), handle);
-            return { ok: true };
+            trackChild(this.children, this.planKey(plan), handle);
+            return { ok: true, handle };
         }
         // llama.cpp renders process and docker plans; a compose plan is a no-op.
         return { ok: true };
@@ -826,14 +976,17 @@ export class StrataAdapter extends EngineAdapter {
             healthUrl: `http://127.0.0.1:${port}/health`,
         };
     }
-    async deploy(plan) {
+    async deploy(plan, _platform, onProgress, _options) {
+        // The image pull is the docker build step: the card's button reads
+        // "Building..." for it.
+        onProgress?.('build');
         const pull = await this.host.run(`docker pull ${STRATA_DOCKER_IMAGE}`);
         if (!pull.ok) {
             return { ok: false, detail: `docker pull failed: ${pull.detail ?? 'unknown'}` };
         }
         const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {});
-        this.children.set(this.planKey(plan), handle);
-        return { ok: true };
+        trackChild(this.children, this.planKey(plan), handle);
+        return { ok: true, handle };
     }
     async healthCheck(plan, options) {
         return pollHealth(this.host, plan, options);
@@ -855,4 +1008,179 @@ export class StrataAdapter extends EngineAdapter {
         return `${plan.engineId}:${plan.port}`;
     }
 }
+/**
+ * InfernixAdapter is the local-only engine for Infernix, the C++/CUDA fork
+ * of NInfer (https://github.com/wallawalla47/infernix) tuned for Qwen models
+ * on a single RTX 50-series GPU. `renderLaunch` renders a local
+ * `infernix-serve` process from the `INFERNIX_PARAMETERS` surface (the
+ * Infernix-only fields, from `--ngram-volume` to the quality routes, spell
+ * onto the argv only for this engine); `deploy` builds the engine in the
+ * engine directory (the engine's own cmake preset), downloads the model
+ * artifact (and the n-gram volume, for the multi-file Flash-Next repo) into
+ * the model directory, and starts the engine; `healthCheck` polls the health
+ * URL; `stop` signals the tracked process. The engine ships no docker image,
+ * so the adapter supports the local build mode only.
+ */
+export class InfernixAdapter extends EngineAdapter {
+    id = 'infernix';
+    supports = { docker: false, local: true };
+    host;
+    children = new Map();
+    constructor(host = nodeLifecycleHost) {
+        super();
+        this.host = host;
+    }
+    parameters() {
+        return INFERNIX_PARAMETERS;
+    }
+    modelRef(config) {
+        // The engine serves the model under the artifact's advertised id, so the
+        // registrar publishes that alias and a chat turn routes to it. A model
+        // key that names a local artifact file (a directory-scanned model)
+        // reuses the 27B alias, the same fallback the NInfer adapter applies.
+        const artifact = infernixArtifactFor(infernixModelKey(config));
+        return { id: artifact.modelId, name: artifact.modelId };
+    }
+    launchSignature(config = {}) {
+        // The local plan runs the infernix-serve binary (the .exe on Windows),
+        // so the binary name is the command-line marker the reserve probe
+        // matches on, and the port the plan binds rides along.
+        return { binary: 'infernix-serve', port: this.port(config) };
+    }
+    renderLaunch(config, _hw) {
+        const port = this.port(config);
+        const modelKey = infernixModelKey(config);
+        const artifact = infernixArtifactFor(modelKey);
+        // A model key that names a local artifact file (a directory-scanned
+        // model, a .ninfer or .infernix name) overrides the artifact map's file,
+        // so a file the user has on disk launches as-is.
+        const file = modelKey.endsWith('.ninfer') || modelKey.endsWith('.infernix')
+            ? modelKey
+            : artifact.file;
+        const modelDirectory = typeof config.modelDirectory === 'string' ? config.modelDirectory : '';
+        const modelPath = modelDirectory === '' ? file : join(modelDirectory, file);
+        // The engine binary is the .exe on a Windows host, where the published
+        // release zip ships the server and its DLLs.
+        const binary = process.platform === 'win32' ? 'infernix-serve.exe' : 'infernix-serve';
+        const flags = flagsFromSpecs(INFERNIX_PARAMETERS, config);
+        // The dflash2 backend always loads a drafter through --draft-model, so the
+        // flag is spelled here from the resolved path (the selected DFlash2 preset,
+        // or the Custom Draft model field) rather than by a spec toArgv. A config
+        // that names no drafter path is the misconfiguration the dflash2
+        // guideline names, so the flag is spelled only when a path resolves.
+        if (config.spec === 'dflash2') {
+            const draftPath = infernixDraftModelPath(config);
+            if (draftPath !== null) {
+                flags.push('--draft-model', draftPath);
+            }
+        }
+        const customArgs = customArgFlags(config);
+        return {
+            engineId: this.id,
+            kind: 'process',
+            argv: [
+                binary,
+                modelPath,
+                '--host',
+                '127.0.0.1',
+                '--port',
+                String(port),
+                '--model-id',
+                artifact.modelId,
+                ...flags,
+                ...customArgs,
+            ],
+            env: {},
+            modelId: modelKey,
+            ...(modelDirectory === '' ? {} : { modelDirectory }),
+            port,
+            healthUrl: `http://127.0.0.1:${port}/health`,
+        };
+    }
+    async deploy(plan, platform, onProgress, options) {
+        if (plan.kind !== 'process') {
+            // Infernix renders process plans only; a docker or compose plan is a
+            // no-op.
+            return { ok: true };
+        }
+        const engineDir = platform?.engineDirectory;
+        let buildLogs = '';
+        // Auto Rebuild off (the card's checkbox): the git sync (fetch, rebase,
+        // rebuild) is skipped and the checkout launches as-is.
+        if (engineDir !== undefined && options?.autoRebuild !== false) {
+            // The git sync is the checkout download: the card's button reads
+            // "Downloading..." for it, not "Building...".
+            onProgress?.('download');
+            // The conditional rebuild fetches the checkout, prices it against the
+            // remote branch, and rebuilds only when it is behind (or a fresh
+            // clone). The engine's own quick start (the cmake preset, then the
+            // preset's build) rides the acquisition-data build steps. The decision,
+            // the build command, and its output are captured into buildLogs and
+            // threaded to the card's Logs section.
+            const sync = await syncAndRebuildEngine(this.host, {
+                engineId: this.id,
+                directory: engineDir,
+                ...(platform?.engineFork !== undefined ? { fork: platform.engineFork } : {}),
+                ...(plan.argv?.[0] !== undefined ? { binary: plan.argv[0] } : {}),
+                ...(options?.allowRunDeps !== undefined ? { allowRunDeps: options.allowRunDeps } : {}),
+            }, () => { });
+            buildLogs = sync.logs;
+            if (!sync.ok) {
+                return { ok: false, detail: sync.detail ?? 'unknown', logs: buildLogs };
+            }
+            // The build step reads as "Building..." only when a build actually
+            // ran (a fresh clone, or a rebase of a checkout that was behind).
+            if (sync.rebuilt) {
+                onProgress?.('build');
+            }
+        }
+        const withLogs = (result) => buildLogs !== '' ? { ...result, logs: buildLogs } : result;
+        onProgress?.('download');
+        const download = await this.downloadModel(plan);
+        if (!download.ok)
+            return withLogs(download);
+        const handle = this.host.spawn(plan.argv ?? [], plan.env ?? {}, engineDir);
+        this.children.set(this.planKey(plan), handle);
+        return withLogs({ ok: true, handle });
+    }
+    async healthCheck(plan, options) {
+        return pollHealth(this.host, plan, options);
+    }
+    async stop(plan) {
+        const handle = this.children.get(this.planKey(plan));
+        if (handle !== undefined) {
+            handle.kill();
+            this.children.delete(this.planKey(plan));
+        }
+    }
+    port(config) {
+        // 8080 is the infernix-serve CLI default, so the form seeds it and the
+        // adapter falls back to it when a config names no port.
+        return typeof config.port === 'number' ? config.port : 8080;
+    }
+    planKey(plan) {
+        return `${plan.engineId}:${plan.port}`;
+    }
+    async downloadModel(plan) {
+        const artifact = plan.modelId !== undefined ? INFERNIX_MODEL_ARTIFACTS[plan.modelId] : undefined;
+        // A model key that names a local artifact file carries no artifact entry,
+        // so the file the user has on disk launches as-is without a download.
+        if (artifact === undefined)
+            return { ok: true };
+        const target = plan.modelDirectory ?? '.';
+        // A multi-file artifact (the Flash-Next shards) downloads the whole repo,
+        // which carries the n-gram volume beside the shards, so the
+        // --ngram-volume flag points at a file the same download left on disk.
+        // A single-file artifact downloads the file alone.
+        const repo = artifact.repo;
+        const files = artifact.files ?? [];
+        const download = files.length > 1
+            ? await this.host.run(`hf download ${repo} --local-dir ${target}`)
+            : await this.host.run(`hf download ${repo} ${artifact.file} --local-dir ${target}`);
+        if (!download.ok) {
+            return { ok: false, detail: `model download failed: ${download.detail ?? 'unknown'}` };
+        }
+        return { ok: true };
+    }
+}
 //# sourceMappingURL=adapters.js.map

package/packages/providers/lib/debug.d.ts

@@ -3,7 +3,7 @@
  * the two ways DSH enables debug mode (the HARNESS_LOG_LEVEL environment
  * variable and the DSH logger level config) into a single DebugLogger the
  * engine adapters use to capture the full build-to-launch command sequence.
- * @module @dsh/dsh-plugin-local-infer/providers/debug
+ * @module dsh-plugin-local-infer/providers/debug
  */
 import { Context } from '@deepseek-ai/cordis';
 import { type DebugLogger } from '../../core/lib/index.js';

package/packages/providers/lib/debug.js

@@ -3,7 +3,7 @@
  * the two ways DSH enables debug mode (the HARNESS_LOG_LEVEL environment
  * variable and the DSH logger level config) into a single DebugLogger the
  * engine adapters use to capture the full build-to-launch command sequence.
- * @module @dsh/dsh-plugin-local-infer/providers/debug
+ * @module dsh-plugin-local-infer/providers/debug
  */
 import { appendFileSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';

package/packages/providers/lib/deps.d.ts

@@ -9,9 +9,9 @@
  *
  * The dnf and brew blocks are the plan's "flagged when untested" sets: they
  * name the right packages but have not been run on a live host.
- * @module @dsh/dsh-plugin-local-infer/providers/deps
+ * @module dsh-plugin-local-infer/providers/deps
  */
-import type { EngineDepPlan, HardwareProfile } from '@dsh/dsh-plugin-local-infer/core';
+import type { EngineDepPlan, HardwareProfile } from 'dsh-plugin-local-infer/core';
 /**
  * The named host deps every engine plan composes. The install blocks are the
  * copy/paste commands the user runs; envAfter carries the per-manager export
@@ -217,8 +217,10 @@ export declare const SYSTEM_DEPS: {
  * The per-engine dep plans, keyed by engine id. The local NInfer list is the
  * qwen-ninfer header's toolchain plus the CUDA toolkit and the hf CLI; the
  * docker lists are the container runtime plus the GPU toolkit plus the hf
- * CLI. llama.cpp and Strata carry the specified-not-verified lists until
- * their adapters land in Phase 5.
+ * CLI. Infernix builds through the engine's own cmake preset, so its local
+ * list is the same toolchain as NInfer's, and its docker list stays empty
+ * because the engine ships no container image. llama.cpp and Strata carry
+ * the specified-not-verified lists until their adapters land in Phase 5.
  */
 export declare const ENGINE_DEP_PLANS: Record<string, EngineDepPlan>;
 //# sourceMappingURL=deps.d.ts.map

package/packages/providers/lib/deps.js

@@ -9,7 +9,7 @@
  *
  * The dnf and brew blocks are the plan's "flagged when untested" sets: they
  * name the right packages but have not been run on a live host.
- * @module @dsh/dsh-plugin-local-infer/providers/deps
+ * @module dsh-plugin-local-infer/providers/deps
  */
 import { execFile } from 'node:child_process';
 /**
@@ -189,8 +189,10 @@ export const SYSTEM_DEPS = {
  * The per-engine dep plans, keyed by engine id. The local NInfer list is the
  * qwen-ninfer header's toolchain plus the CUDA toolkit and the hf CLI; the
  * docker lists are the container runtime plus the GPU toolkit plus the hf
- * CLI. llama.cpp and Strata carry the specified-not-verified lists until
- * their adapters land in Phase 5.
+ * CLI. Infernix builds through the engine's own cmake preset, so its local
+ * list is the same toolchain as NInfer's, and its docker list stays empty
+ * because the engine ships no container image. llama.cpp and Strata carry
+ * the specified-not-verified lists until their adapters land in Phase 5.
  */
 export const ENGINE_DEP_PLANS = {
     ninfer: {
@@ -213,6 +215,18 @@ export const ENGINE_DEP_PLANS = {
         local: [SYSTEM_DEPS.cmake, SYSTEM_DEPS.hfCli],
         docker: [SYSTEM_DEPS.docker, SYSTEM_DEPS.hfCli],
     },
+    infernix: {
+        local: [
+            SYSTEM_DEPS.cmake,
+            SYSTEM_DEPS.ninja,
+            SYSTEM_DEPS.pkgConfig,
+            SYSTEM_DEPS.ffmpeg,
+            SYSTEM_DEPS.curl,
+            SYSTEM_DEPS.cudaToolkit,
+            SYSTEM_DEPS.hfCli,
+        ],
+        docker: [],
+    },
     strata: {
         local: [],
         docker: [SYSTEM_DEPS.docker, SYSTEM_DEPS.hfCli],