dsh-plugin-local-infer 0.1.3 → 0.1.4

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

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

@@ -1,11 +1,14 @@
 /**
- * NInfer VramModel data. The measured memory constants for the two Qwen
- * artifacts NInfer serves, ported from `docs/config-calculator.html` in the
- * NInfer fork: every byte figure is measured on an RTX 3090 (24 GiB, sm_86,
- * CUDA 12.8) against the engine's own capacity report, not estimated from
- * parameter counts. The provenance note on each model names the exact weight
- * artifact the figures apply to, because the runtime also recognizes other
- * weight profiles with different resident sizes.
+ * VramModel data for the engines the card prices. The NInfer models are the
+ * measured memory constants for the two Qwen artifacts NInfer serves, ported
+ * from `docs/config-calculator.html` in the NInfer fork: every byte figure is
+ * measured on an RTX 3090 (24 GiB, sm_86, CUDA 12.8) against the engine's own
+ * capacity report, not estimated from parameter counts. The provenance note on
+ * each model names the exact weight artifact the figures apply to, because the
+ * runtime also recognizes other weight profiles with different resident sizes.
+ * The Basalt models are the estimated sets for the engine's `.basalt`
+ * artifacts: the measured figures are not yet available, so their terms are
+ * estimated from the model size and flagged `source: 'estimated'`.
  * @module dsh-plugin-local-infer/providers/vram
  */
 import type { VramModel } from 'dsh-plugin-local-infer/core';
@@ -21,4 +24,27 @@ export declare const NINFER_VRAM_MODELS: readonly VramModel[];
  * Resolves one NInfer VramModel by its registry id, e.g. `qwen3-27b`.
  */
 export declare function ninferVramModel(modelId: string): VramModel | undefined;
-//# sourceMappingURL=vram.d.ts.map
+/**
+ * The Basalt estimated VramModels, one per `.basalt` artifact the engine
+ * serves.
+ *
+ * The first is the Qwen3.8-Flash-Next NVFP4 artifact
+ * (`Qwen3.8-FN-NVFP4-DQ6_K.basalt`). The measured figures are not yet
+ * available, so every term is estimated from the model size, not measured
+ * against the engine: the weights price a ~48B-total-parameter MoE in NVFP4
+ * (0.5 bytes per parameter, ~24 GiB), and the KV per-token terms price a
+ * 48-layer, 8-KV-head, 128-head-dim GQA layout across the four KV formats
+ * Basalt serves (fp16, int8, q4_0, k8v4). The `source: 'estimated'` flag is
+ * what keeps the meter from reading these as authoritative.
+ *
+ * Basalt's `spec` setting is a token-window count (a number), not a named
+ * speculation backend, so neither model carries a `speculation` table or a
+ * `specKey`: the estimator prices them from the base terms.
+ */
+export declare const BASALT_VRAM_MODELS: readonly VramModel[];
+/**
+ * Resolves a Basalt VramModel by its registry id, `qwen38-flash-next` or
+ * `deepseek-v41-flash`.
+ */
+export declare function basaltVramModel(modelId: string): VramModel | undefined;
+//# sourceMappingURL=vram.d.ts.map