dsh-plugin-local-infer 0.1.2 → 0.1.4

package/packages/providers/lib/presets.js

@@ -2,10 +2,12 @@
  * Built-in preset data for the local-inference defaults layer. The presets are
  * the offline floor the DefaultsResolver resolves against: the NInfer
  * measured configs (the `config-calculator.html` figures and the
- * `qwen-ninfer` launcher, on a 24 GiB sm86 card) and the Hyper-Qwen `.env`
+ * `qwen-ninfer` launcher, on a 24 GiB sm86 card), the Hyper-Qwen `.env`
  * profiles (the single-user speed, long-context, and huge-context tiers from
- * `.env.example`). Each preset is keyed by its exact (engine, model, hardware
- * class) triple, so it is only trusted for the hardware it was sourced for.
+ * `.env.example`), and the Basalt Blackwell long-context starting config
+ * (keyed to the wildcard class, since Basalt runs on any Blackwell card).
+ * Each preset is keyed by its exact (engine, model, hardware class) triple, so
+ * it is only trusted for the hardware it was sourced for.
  *
  * The `PRESET_SOURCES` list names the mod-search fetch path: the URL the
  * bridge pulls and the pure extractor that turns the fetched page into a
@@ -13,6 +15,8 @@
  * fetch date.
  * @module dsh-plugin-local-infer/providers/presets
  */
+import { WILDCARD_HARDWARE_CLASS } from '../../core/lib/index.js';
+import { BASALT_DEEPSEEK_MODEL_ID, BASALT_DEFAULT_MODEL_ID, } from "./engines/basalt/basalt.js";
 /**
  * The hardware class every built-in preset is sourced for: a 24 GiB Ampere
  * (sm86) card, the card the NInfer constants were measured on and the card the
@@ -118,11 +122,55 @@ const HYPERQWEN_PRESETS = [
         label: 'huge-context',
     },
 ];
+/**
+ * The Basalt built-in presets, keyed to the wildcard hardware class. Basalt
+ * is Blackwell-only, so each row is the sane long-context starting config
+ * the resolver offers for one artifact on any detected Blackwell card, and
+ * each model's own row is its default (the resolver keys presets by the
+ * exact engine/model/class triple). The Qwen3.8-Flash-Next NVFP4 row sets
+ * int8 KV (half the bytes of the fp16 default) and a 32k context; the
+ * DeepSeek-V4.1-Flash UD-IQ1_M row sets only the 32k context, because the
+ * pack has no KV-format choice. The engine's own spec defaults (the
+ * drafter window, the expert cache, the resident experts) stay at their
+ * surface defaults.
+ */
+const BASALT_PRESETS = [
+    {
+        engineId: 'basalt',
+        modelId: BASALT_DEFAULT_MODEL_ID,
+        hardwareClass: WILDCARD_HARDWARE_CLASS,
+        values: {
+            kv: 'int8',
+            maxContext: 32768,
+        },
+        source: 'Basalt built-in (Blackwell long-context starting config)',
+        label: 'long-context',
+        isDefault: true,
+    },
+    {
+        engineId: 'basalt',
+        modelId: BASALT_DEEPSEEK_MODEL_ID,
+        hardwareClass: WILDCARD_HARDWARE_CLASS,
+        // No kv: the DeepSeek pack has no KV-format choice, and a flag the
+        // model lacks stops the start from a model entry (the surface keeps kv
+        // in the shared engine block, where it is skipped for this model).
+        values: {
+            maxContext: 32768,
+        },
+        source: 'Basalt built-in (Blackwell long-context starting config)',
+        label: 'long-context',
+        isDefault: true,
+    },
+];
 /**
  * BUILTIN_PRESETS is the combined preset list the providers register with the
  * seam. Adding a preset is a data edit here, never a resolver change.
  */
-export const BUILTIN_PRESETS = [...NINFER_PRESETS, ...HYPERQWEN_PRESETS];
+export const BUILTIN_PRESETS = [
+    ...NINFER_PRESETS,
+    ...HYPERQWEN_PRESETS,
+    ...BASALT_PRESETS,
+];
 /**
  * extractJsonBlock reads the first fenced ```json block out of a fetched page
  * and parses it as the preset values. A page with no json block (or a broken
@@ -158,4 +206,4 @@ export const PRESET_SOURCES = [
         extract: extractJsonBlock,
     },
 ];
-//# sourceMappingURL=presets.js.map
+//# sourceMappingURL=presets.js.map

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

@@ -0,0 +1,313 @@
+/**
+ * The shared SystemDep install command catalog. Every engine OS profile and
+ * the per-engine dep plans compose their lists from these named deps, so the
+ * install blocks (the copy/paste commands the user runs) and the which/version
+ * probes have one home. The engine OS profiles import this catalog directly,
+ * which keeps them free of a circular edge back through the per-engine plans.
+ *
+ * Each dep declares its purpose, the which/version probe that reads "already
+ * installed", and its install block keyed by package manager, mirroring the
+ * qwen-ninfer launcher header (apt and the CUDA keyring on Debian/Ubuntu,
+ * pacman on Arch). 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-plugin-local-infer/providers/systemDeps
+ */
+import type { 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
+ * lines (the CUDA paths differ between Debian and Arch).
+ */
+export declare const SYSTEM_DEPS: {
+    cmake: {
+        id: string;
+        purpose: string;
+        requiresSudo: true;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            apt: {
+                commands: string[];
+            };
+            dnf: {
+                commands: string[];
+            };
+            pacman: {
+                commands: string[];
+            };
+            brew: {
+                commands: string[];
+            };
+            winget: {
+                commands: string[];
+            };
+        };
+    };
+    ninja: {
+        id: string;
+        purpose: string;
+        requiresSudo: true;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            apt: {
+                commands: string[];
+            };
+            dnf: {
+                commands: string[];
+            };
+            pacman: {
+                commands: string[];
+            };
+            brew: {
+                commands: string[];
+            };
+            winget: {
+                commands: string[];
+            };
+        };
+    };
+    visualStudio: {
+        id: string;
+        purpose: string;
+        requiresSudo: false;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            winget: {
+                commands: string[];
+            };
+        };
+    };
+    pkgConfig: {
+        id: string;
+        purpose: string;
+        requiresSudo: true;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            apt: {
+                commands: string[];
+            };
+            dnf: {
+                commands: string[];
+            };
+            pacman: {
+                commands: string[];
+            };
+            brew: {
+                commands: string[];
+            };
+        };
+    };
+    ffmpeg: {
+        id: string;
+        purpose: string;
+        requiresSudo: true;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            apt: {
+                commands: string[];
+            };
+            dnf: {
+                commands: string[];
+            };
+            pacman: {
+                commands: string[];
+            };
+            brew: {
+                commands: string[];
+            };
+        };
+    };
+    curl: {
+        id: string;
+        purpose: string;
+        requiresSudo: true;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            apt: {
+                commands: string[];
+            };
+            dnf: {
+                commands: string[];
+            };
+            pacman: {
+                commands: string[];
+            };
+            brew: {
+                commands: string[];
+            };
+        };
+    };
+    cudaToolkit: {
+        id: string;
+        purpose: string;
+        requiresSudo: true;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            apt: {
+                commands: string[];
+                envAfter: {
+                    CUDACXX: string;
+                };
+            };
+            dnf: {
+                commands: string[];
+                envAfter: {
+                    CUDACXX: string;
+                };
+            };
+            pacman: {
+                commands: string[];
+                envAfter: {
+                    CUDAToolkit_ROOT: string;
+                    CUDACXX: string;
+                    TORCH_CUDA_ARCH_LIST: string;
+                };
+            };
+            brew: {
+                commands: string[];
+                envAfter: {
+                    CUDACXX: string;
+                };
+            };
+            winget: {
+                commands: string[];
+            };
+        };
+    };
+    compiler: {
+        id: string;
+        purpose: string;
+        requiresSudo: true;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            apt: {
+                commands: string[];
+            };
+            dnf: {
+                commands: string[];
+            };
+            pacman: {
+                commands: string[];
+            };
+            brew: {
+                commands: string[];
+            };
+            winget: {
+                commands: never[];
+            };
+        };
+    };
+    git: {
+        id: string;
+        purpose: string;
+        requiresSudo: true;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            apt: {
+                commands: string[];
+            };
+            dnf: {
+                commands: string[];
+            };
+            pacman: {
+                commands: string[];
+            };
+            brew: {
+                commands: string[];
+            };
+            winget: {
+                commands: string[];
+            };
+        };
+    };
+    docker: {
+        id: string;
+        purpose: string;
+        requiresSudo: true;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            apt: {
+                commands: string[];
+            };
+            dnf: {
+                commands: string[];
+            };
+            pacman: {
+                commands: string[];
+            };
+            brew: {
+                commands: string[];
+            };
+            winget: {
+                commands: string[];
+            };
+        };
+    };
+    nvidiaContainerToolkit: {
+        id: string;
+        purpose: string;
+        requiresSudo: true;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            apt: {
+                commands: string[];
+            };
+            dnf: {
+                commands: string[];
+            };
+            pacman: {
+                commands: string[];
+            };
+            brew: {
+                commands: never[];
+            };
+        };
+    };
+    hfCli: {
+        id: string;
+        purpose: string;
+        requiresSudo: false;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            apt: {
+                commands: string[];
+            };
+            dnf: {
+                commands: string[];
+            };
+            pacman: {
+                commands: string[];
+            };
+            brew: {
+                commands: string[];
+            };
+            winget: {
+                commands: string[];
+            };
+        };
+    };
+    basaltPip: {
+        id: string;
+        purpose: string;
+        requiresSudo: true;
+        detect: (hw: HardwareProfile) => Promise<boolean>;
+        install: {
+            apt: {
+                commands: string[];
+            };
+            dnf: {
+                commands: string[];
+            };
+            pacman: {
+                commands: string[];
+            };
+            brew: {
+                commands: string[];
+            };
+            winget: {
+                commands: string[];
+            };
+        };
+    };
+};
+//# sourceMappingURL=systemDeps.d.ts.map

package/packages/providers/lib/systemDeps.js

@@ -0,0 +1,284 @@
+/**
+ * The shared SystemDep install command catalog. Every engine OS profile and
+ * the per-engine dep plans compose their lists from these named deps, so the
+ * install blocks (the copy/paste commands the user runs) and the which/version
+ * probes have one home. The engine OS profiles import this catalog directly,
+ * which keeps them free of a circular edge back through the per-engine plans.
+ *
+ * Each dep declares its purpose, the which/version probe that reads "already
+ * installed", and its install block keyed by package manager, mirroring the
+ * qwen-ninfer launcher header (apt and the CUDA keyring on Debian/Ubuntu,
+ * pacman on Arch). 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-plugin-local-infer/providers/systemDeps
+ */
+import { execFile } from 'node:child_process';
+/**
+ * The probe timeout. A hung version probe must not hang the panel, so every
+ * detect command is killed after this many milliseconds and read as missing.
+ */
+const PROBE_TIMEOUT_MS = 5000;
+/**
+ * probe builds a dep's detect function from a binary and its version args.
+ * A missing binary, a non-zero exit, and a timeout all read as not installed,
+ * which the checkDeps rule degrades to the missing status.
+ */
+function probe(binary, args) {
+    return async (_hw) => {
+        try {
+            await execFile(binary, args, { timeout: PROBE_TIMEOUT_MS });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+}
+/**
+ * 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
+ * lines (the CUDA paths differ between Debian and Arch).
+ */
+export const SYSTEM_DEPS = {
+    cmake: {
+        id: 'cmake',
+        purpose: 'compiles the local engine',
+        requiresSudo: true,
+        detect: probe('cmake', ['--version']),
+        install: {
+            apt: { commands: ['sudo apt install cmake'] },
+            dnf: { commands: ['sudo dnf install cmake'] },
+            pacman: { commands: ['sudo pacman -S --noconfirm cmake'] },
+            brew: { commands: ['brew install cmake'] },
+            winget: { commands: ['winget install Kitware.CMake'] },
+        },
+    },
+    ninja: {
+        id: 'ninja',
+        purpose: 'drives the cmake build',
+        requiresSudo: true,
+        detect: probe('ninja', ['--version']),
+        install: {
+            apt: { commands: ['sudo apt install ninja-build'] },
+            dnf: { commands: ['sudo dnf install ninja'] },
+            pacman: { commands: ['sudo pacman -S --noconfirm ninja'] },
+            brew: { commands: ['brew install ninja'] },
+            winget: { commands: ['winget install -e --id Ninja-build.Ninja'] },
+        },
+    },
+    // The MSVC compiler the Windows vcpkg build links against. The winget block
+    // installs the Community edition with the C++ workload the build needs. The
+    // probe reads the cl compiler, which is on the path only inside a Visual
+    // Studio developer prompt, so a plain shell degrades to missing and the
+    // user installs by hand.
+    visualStudio: {
+        id: 'visual-studio',
+        purpose: 'provides the MSVC compiler the vcpkg build needs',
+        requiresSudo: false,
+        detect: probe('where', ['cl']),
+        install: {
+            // The MSVC C++ workload the Windows Basalt build needs. Untested on a
+            // live host, so it rides the plan's "flagged when untested" rule.
+            winget: {
+                commands: [
+                    'winget install --id Microsoft.VisualStudio.Community --override "--passive --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended"',
+                ],
+            },
+        },
+    },
+    pkgConfig: {
+        id: 'pkg-config',
+        purpose: 'links the ffmpeg and curl dev libraries',
+        requiresSudo: true,
+        detect: probe('pkg-config', ['--version']),
+        install: {
+            apt: { commands: ['sudo apt install pkg-config'] },
+            dnf: { commands: ['sudo dnf install pkgconf-pkg-config'] },
+            pacman: { commands: ['sudo pacman -S --noconfirm pkgconf'] },
+            brew: { commands: ['brew install pkgconf'] },
+        },
+    },
+    ffmpeg: {
+        id: 'ffmpeg',
+        purpose: 'links the media codecs the vision tower needs',
+        requiresSudo: true,
+        detect: probe('ffmpeg', ['-version']),
+        install: {
+            apt: {
+                commands: ['sudo apt install libavformat-dev libavcodec-dev libavutil-dev libswscale-dev'],
+            },
+            dnf: { commands: ['sudo dnf install ffmpeg-devel'] },
+            pacman: { commands: ['sudo pacman -S --noconfirm ffmpeg'] },
+            brew: { commands: ['brew install ffmpeg'] },
+        },
+    },
+    curl: {
+        id: 'curl',
+        purpose: 'links the HTTP client dev headers',
+        requiresSudo: true,
+        detect: probe('curl', ['--version']),
+        install: {
+            apt: { commands: ['sudo apt install libcurl4-openssl-dev'] },
+            dnf: { commands: ['sudo dnf install libcurl-devel'] },
+            pacman: { commands: ['sudo pacman -S --noconfirm curl'] },
+            brew: { commands: ['brew install curl'] },
+        },
+    },
+    // The CUDA 13 toolkit the Blackwell-only Basalt build needs. None of the
+    // manager blocks below has been run on a live host, so each rides the
+    // plan's "flagged when untested" rule: a later live-host run confirms the
+    // exact package names.
+    cudaToolkit: {
+        id: 'cuda-toolkit',
+        purpose: 'compiles the CUDA kernels',
+        requiresSudo: true,
+        detect: probe('nvcc', ['--version']),
+        install: {
+            // The qwen-ninfer header, verbatim: the ubuntu2604 CUDA keyring plus the
+            // toolkit, then the nvcc export the build reads.
+            apt: {
+                commands: [
+                    'wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2604/x86_64/cuda-keyring_1.1-1_all.deb',
+                    'sudo dpkg -i cuda-keyring_1.1-1_all.deb',
+                    'sudo apt-get update',
+                    'sudo apt-get -y install cuda-toolkit-13-4',
+                ],
+                envAfter: { CUDACXX: '/usr/local/cuda/bin/nvcc' },
+            },
+            dnf: {
+                commands: ['sudo dnf install cuda-toolkit'],
+                envAfter: { CUDACXX: '/usr/bin/nvcc' },
+            },
+            pacman: {
+                commands: ['sudo pacman -S --noconfirm cuda'],
+                envAfter: {
+                    CUDAToolkit_ROOT: '/opt/cuda',
+                    CUDACXX: '/opt/cuda/bin/nvcc',
+                    TORCH_CUDA_ARCH_LIST: '12.0',
+                },
+            },
+            brew: {
+                commands: ['brew install --cask nvidia-cuda'],
+                envAfter: { CUDACXX: '/usr/local/cuda/bin/nvcc' },
+            },
+            // The NVIDIA CUDA toolkit the winget catalog ships. The build reads the
+            // toolkit from the default install path, so no envAfter export is needed.
+            winget: { commands: ['winget install --id=Nvidia.CUDA -e'] },
+        },
+    },
+    // The C++20 compiler the local build links against (GCC on Debian/Arch/
+    // Fedora, Clang on macOS). The winget block is empty: on Windows the C++20
+    // compiler is the MSVC toolchain the visual-studio dep installs, so the
+    // Windows profile rides that dep instead of this one.
+    compiler: {
+        id: 'compiler',
+        purpose: 'compiles the C++20 engine sources',
+        requiresSudo: true,
+        detect: probe('g++', ['--version']),
+        install: {
+            apt: { commands: ['sudo apt install g++'] },
+            dnf: { commands: ['sudo dnf install gcc-c++'] },
+            pacman: { commands: ['sudo pacman -S --noconfirm gcc'] },
+            brew: { commands: ['brew install gcc'] },
+            winget: { commands: [] },
+        },
+    },
+    git: {
+        id: 'git',
+        purpose: 'clones the engine source',
+        requiresSudo: true,
+        detect: probe('git', ['--version']),
+        install: {
+            apt: { commands: ['sudo apt install git'] },
+            dnf: { commands: ['sudo dnf install git'] },
+            pacman: { commands: ['sudo pacman -S --noconfirm git'] },
+            brew: { commands: ['brew install git'] },
+            winget: { commands: ['winget install Git.Git'] },
+        },
+    },
+    docker: {
+        id: 'docker',
+        purpose: 'runs the engine in a container',
+        requiresSudo: true,
+        detect: probe('docker', ['--version']),
+        install: {
+            apt: { commands: ['sudo apt install docker.io'] },
+            dnf: { commands: ['sudo dnf install docker'] },
+            pacman: { commands: ['sudo pacman -S --noconfirm docker'] },
+            brew: { commands: ['brew install --cask docker'] },
+            winget: { commands: ['winget install Docker.Docker-Desktop'] },
+        },
+    },
+    nvidiaContainerToolkit: {
+        id: 'nvidia-container-toolkit',
+        purpose: 'lets the container see the GPU',
+        requiresSudo: true,
+        detect: probe('nvidia-ctk', ['--version']),
+        install: {
+            // The NVIDIA-published apt setup. Untested on a live host, so it rides
+            // the plan's "flagged when untested" rule.
+            apt: {
+                commands: [
+                    'curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg',
+                    'curl -fsSL https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | sed \'s#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#\' | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list',
+                    'sudo apt-get update',
+                    'sudo apt-get install -y nvidia-container-toolkit',
+                ],
+            },
+            dnf: { commands: ['sudo dnf install nvidia-container-toolkit'] },
+            pacman: { commands: ['sudo pacman -S --noconfirm nvidia-container-toolkit'] },
+            // macOS has no NVIDIA GPU toolkit; the by-hand note renders instead.
+            brew: { commands: [] },
+        },
+    },
+    hfCli: {
+        id: 'hf-cli',
+        purpose: 'downloads the model artifact',
+        requiresSudo: false,
+        detect: probe('hf', ['--version']),
+        install: {
+            // The hf CLI installs through its own script, not a package manager, so
+            // every manager keys the same block. Windows runs the PowerShell
+            // installer through the OS's own irm alias.
+            apt: { commands: ['curl -LsSf https://hf.co/cli/install.sh | bash'] },
+            dnf: { commands: ['curl -LsSf https://hf.co/cli/install.sh | bash'] },
+            pacman: { commands: ['curl -LsSf https://hf.co/cli/install.sh | bash'] },
+            brew: { commands: ['curl -LsSf https://hf.co/cli/install.sh | bash'] },
+            winget: {
+                commands: ['powershell -ExecutionPolicy ByPass -c "irm https://hf.co/cli/install.ps1 | iex"'],
+            },
+        },
+    },
+    // The Python packages the Basalt serve/ server imports (numpy, jinja2,
+    // regex, pyyaml, tqdm, pillow, psutil). The C++ basalt binary launches the
+    // Python server, which fails at import when a module is missing, so the
+    // launch reads as a 120-attempt health-poll timeout. The serve CLI resolves
+    // its python as <src_dir>/.venv/bin/python if present, else the system
+    // python3 (python_interpreter in src/platform/system.cpp), so the probe and
+    // install target the system python the CLI falls back to. The probe imports
+    // the modules the server needs; the install pulls them through pip. The
+    // install bootstraps pip through the package manager (python3-pip on
+    // apt/dnf, python-pip on pacman) first, because the system python3 may lack
+    // the pip module (Arch without python-pip).
+    basaltPip: {
+        id: 'basalt-pip',
+        purpose: 'installs the Basalt serve server Python requirements',
+        requiresSudo: true,
+        detect: probe('python3', ['-c', 'import regex, numpy, jinja2, yaml, tqdm, PIL, psutil']),
+        install: {
+            // PEP 668: on Arch / CachyOS, Debian 12+, and Ubuntu 23.04+ the system
+            // python3 is externally managed, so the pip install passes
+            // --break-system-packages. The brew and winget interpreters are not
+            // externally managed, so they run the plain install.
+            apt: { commands: ['sudo apt-get install -y python3-pip && sudo python3 -m pip install --break-system-packages numpy jinja2 markupsafe regex pyyaml tqdm pillow psutil'] },
+            dnf: { commands: ['sudo dnf install -y python3-pip && sudo python3 -m pip install --break-system-packages numpy jinja2 markupsafe regex pyyaml tqdm pillow psutil'] },
+            pacman: { commands: ['sudo pacman -S --noconfirm python-pip && sudo python3 -m pip install --break-system-packages numpy jinja2 markupsafe regex pyyaml tqdm pillow psutil'] },
+            brew: { commands: ['python3 -m pip install numpy jinja2 markupsafe regex pyyaml tqdm pillow psutil'] },
+            // The Windows interpreter is python, not python3, so the winget host
+            // installs through the python alias the OS ships.
+            winget: { commands: ['python -m pip install numpy jinja2 markupsafe regex pyyaml tqdm pillow psutil'] },
+        },
+    },
+};
+//# sourceMappingURL=systemDeps.js.map