dsh-plugin-local-infer 0.1.3 → 0.1.4

package/packages/ui/lib/viewmodels/depsHelpers.js

@@ -5,29 +5,90 @@
  * re-check, so the "Get" gate opens only after a re-check passes.
  * @module dsh-plugin-local-infer/ui/viewmodels/depsHelpers
  */
+import { SUDO_CLI_NOTE } from '../../../core/lib/index.js';
+import { runLogKey } from '../../../service/lib/index.js';
 import { readConfig } from "../config.js";
+import { captureRunBaseline, finishRunSection, INSTALL_RUN_SEED } from "../ops/logs.js";
+import { registerSudoObserver } from "../ops/engine.js";
 import { RouteError } from "../route.js";
 import { buildDeps } from "./deps.js";
 /**
  * runInstallFor is the Play/Run path: it refuses with a 409 while the
  * trust gate is off (the copy/paste path is always the fallback), runs the
  * install through the service, and refreshes the deps model from the
- * re-check, so the "Get" gate opens only after a re-check passes.
+ * re-check, so the "Get" gate opens only after a re-check passes. A run that
+ * actually starts brackets one live hub run under the runLogKey rule (the
+ * stored entry matching the engine and model, else the engine id): the seed
+ * is the "Installing deps..." separator, the service writes each install
+ * command's `$ <command>` line into the run (through onLog) before its child
+ * spawns, each per-dep install result appends in the Get step's
+ * `  <id>: <status>` shape, and the run ends at settle, a throwing install
+ * included. The settle text also folds through the shared run-section persister
+ * (finishRunSection over the pre-run baseline), so the last install run
+ * survives a card reload in the stored last-run logs and the log file, like
+ * the other provider processes; the baseline close keeps the sudo note the
+ * observer persists mid-run from landing twice. The run registers the sudo
+ * hook the launch and Get paths register, so a guarded dependency install
+ * waiting for a password on the CLI lands the shared SUDO_CLI_NOTE line in
+ * the live run and the persisted run. A 409 refusal starts no run.
  */
 export async function runInstallFor(localInfer, request) {
-    if (readConfig().allowRunDeps !== true) {
+    const stored = readConfig();
+    if (stored.allowRunDeps !== true) {
         throw new RouteError(409, 'one-click install is not allowed; copy the install string instead');
     }
     const model = await buildDeps(localInfer, request);
     const hardware = await localInfer.detectHardware();
-    const result = await localInfer.runInstall(model.engineId, model.buildMode, hardware);
-    const deps = model.deps.map((dep) => {
-        const entry = result.results.find((entry) => entry.id === dep.id);
-        return entry === undefined ? dep : { ...dep, status: entry.status };
-    });
-    return {
-        result,
-        deps: { ...model, deps, allSatisfied: result.ok },
+    const runKey = runLogKey(stored.providers, model.engineId, undefined, request.config ?? stored.config);
+    // The install run owns a sudo hook under its run key (the shared
+    // registerSudoObserver wiring): a guarded install waiting on the CLI writes
+    // the core CLI note into the live hub and, through persistProcessLog inside
+    // the helper, into the persisted run and log file, so a hung install reads
+    // where the prompt landed. The disposer clears only this run's slot.
+    // One append feeds both readers: the live hub run and the run's collected
+    // settle text (persisted at the finally), no second copy of the text.
+    let collected = '';
+    const append = (line) => {
+        collected += line;
+        localInfer.appendRunLog(runKey, line);
     };
+    const clearSudoObserver = registerSudoObserver(localInfer, runKey, `${SUDO_CLI_NOTE}\n`, append);
+    // The stored last-run logs as they stand before the run persists anything:
+    // the sudo observer persists its note while the run hangs on the prompt,
+    // and finishRunSection closes the run over the baseline so that provisional
+    // line and the collected run text persist once (the Get route's pattern).
+    const baseline = captureRunBaseline();
+    localInfer.beginRun(runKey, INSTALL_RUN_SEED);
+    try {
+        const result = await localInfer.runInstall(model.engineId, model.buildMode, hardware, {
+            // Each install command's `$ <command>` line reaches the live hub and the
+            // collected run before the guarded runner spawns the child, so the run
+            // reads the command ahead of the per-dep results below.
+            onLog: append,
+        });
+        // The per-dep results stream as the re-check reported them, in the same
+        // indented shape the Get step's dep block logs, so both readers (the
+        // live buffer and, later, a re-rendered Logs pane) say the same thing.
+        for (const entry of result.results) {
+            append(`  ${entry.id}: ${entry.status}${entry.detail !== undefined ? ` (${entry.detail})` : ''}\n`);
+        }
+        const deps = model.deps.map((dep) => {
+            const entry = result.results.find((entry) => entry.id === dep.id);
+            return entry === undefined ? dep : { ...dep, status: entry.status };
+        });
+        return {
+            result,
+            deps: { ...model, deps, allSatisfied: result.ok },
+        };
+    }
+    finally {
+        clearSudoObserver();
+        // The settle fold: the run's text (seed, command lines, per-dep results,
+        // any sudo note) persists as one section so a card reload still shows the
+        // last install run. A throwing install persists the partial section (the
+        // commands that ran) before the error reaches the route.
+        finishRunSection(baseline, `${INSTALL_RUN_SEED}${collected}`);
+        localInfer.endRun(runKey);
+    }
 }
-//# sourceMappingURL=depsHelpers.js.map
+//# sourceMappingURL=depsHelpers.js.map

package/packages/ui/lib/viewmodels/summary.d.ts

@@ -33,6 +33,7 @@ export interface LocalInferSummary {
         };
         defaultBuildCommand?: string;
         defaultDockerTag?: string;
+        defaultEngineDirectory: string;
     }[];
     models: {
         id: string;
@@ -66,7 +67,10 @@ export interface LocalInferSummary {
  * ProviderSummaryEntry is the card-facing view of one saved provider config:
  * the stable id the card edits and deletes against, the engine and model the
  * title renders ("NInfer: <model>"), the running-state the status dot paints,
- * and the full config and platform the expanded form draws from.
+ * the per-provider Auto Rebuild checkbox value the edit form and the entry
+ * launch read, and the full config and platform the expanded form draws from.
+ * An entry saved before the autoRebuild key existed carries no key, so the
+ * card draws the checkbox unchecked.
  */
 export interface ProviderSummaryEntry {
     id: string;
@@ -75,6 +79,7 @@ export interface ProviderSummaryEntry {
     status: ProviderStatus;
     config: Config;
     platform: StoredPlatformConfig;
+    autoRebuild?: boolean;
 }
 /**
  * ModelDefaultModel is the card-facing view of one default model entry: the
@@ -137,4 +142,4 @@ export declare function buildSummary(localInfer: LocalInferService, request?: {
     engine?: string;
     config?: Config;
 }): Promise<LocalInferSummary>;
-//# sourceMappingURL=summary.d.ts.map
+//# sourceMappingURL=summary.d.ts.map

package/packages/ui/lib/viewmodels/summary.js

@@ -8,9 +8,7 @@
  * are the single source the red banner and the inline warnings agree on.
  * @module dsh-plugin-local-infer/ui/viewmodels/summary
  */
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { buildModelEntry, CHAT_TEMPLATE_FILE, hfChatTemplateCommand, hfDownloadCommand, modelArtifactPath, modelEntriesForEngine, } from '../../../core/lib/index.js';
+import { buildModelEntry, chatTemplatePresent, dshEngineCacheDirectory, hfChatTemplateCommand, hfDownloadCommand, modelArtifactPresent, modelCacheEntriesForEngine, modelEntriesForEngine, resolveModelDirectory, } from '../../../core/lib/index.js';
 import { defaultModelFor, defaultModelsForEngine, ENGINES, enginePlatformDefaults, } from '../../../providers/lib/index.js';
 import { readConfig } from "../config.js";
 import { renderForm } from "../form.js";
@@ -33,16 +31,15 @@ export async function buildSummary(localInfer, request) {
     const engineId = request?.engine ?? stored.engine;
     // ENGINES is a known non-empty constant, so the fallback is always defined.
     const engine = ENGINES.find((entry) => entry.id === engineId) ?? ENGINES[0];
-    // The Model Directory field defaults to the plugin's model download
-    // directory (~/.dsh/models, created when absent), so the card always
-    // seeds a real path the deploy step can target. A stored or requested
-    // directory that is a non-blank string wins over the default.
-    const modelDirectory = localInfer.defaultModelDirectory();
-    const rawConfig = request?.config ?? stored.config;
-    const config = typeof rawConfig.modelDirectory === 'string' && rawConfig.modelDirectory.trim() !== ''
-        ? rawConfig
-        : { ...rawConfig, modelDirectory };
-    const modelDir = typeof config.modelDirectory === 'string' ? config.modelDirectory : modelDirectory;
+    // The config the card edits is exactly what is stored or requested: the
+    // summary never backfills a default modelDirectory into it, so a Save of a
+    // default install writes no `modelDirectory` override and the card's field
+    // stays blank (blank means the derived default).
+    const config = request?.config ?? stored.config;
+    // The hub cache root: the plugin's model download home (created when
+    // absent), the base the cache-layout presence checks join onto and the
+    // fallback directory when nothing is cached yet.
+    const hubCacheRoot = localInfer.defaultModelDirectory();
     const hardware = await localInfer.detectHardware();
     // The model value the card carries maps onto the VramModel registry key the
     // estimator prices: a default-model selection is already a registry key, a
@@ -64,17 +61,32 @@ export async function buildSummary(localInfer, request) {
     const defaults = await localInfer.resolveDefaults(engine.id, modelId, hardware, pricedConfig);
     const estimate = await localInfer.estimate(defaults.config, hardware, engine.id);
     const guidelineResults = await localInfer.guidelines(defaults.config, hardware, engine.id);
-    // The directory scan lists the model files the selected engine can serve
-    // straight from the model directory, so the card's Model dropdown offers
-    // them beside the defaults. A missing directory reads as an empty list.
-    const modelFiles = modelEntriesForEngine(localInfer.listModelDirectory(modelDir), engine.id);
+    // The selected default entry: the resolved directory, the model status, and
+    // the download commands all read it; undefined when no default names the
+    // model.
+    const entry = defaultModelFor(engine.id, modelId);
+    // The shared model-directory resolution reads the raw config field (never
+    // a backfilled copy): the override keeps the flat layout, and the hub-cache
+    // layout names the hf download result (the snapshot holding the selected
+    // artifact) or the hub cache root as the display directory, with the base
+    // the presence checks join onto. The display directory is never persisted
+    // back into the stored config.
+    const resolution = resolveModelDirectory(config.modelDirectory, entry, hubCacheRoot);
+    const modelDirectory = resolution.directory;
+    // The model scan lists the models the selected engine can serve: the hub
+    // cache's `models--*` directories (the repo ids, filtered by the engine's
+    // artifact types) when the model directory is the plugin default, else the
+    // flat directory's top-level entries. A missing directory reads as an empty
+    // list.
+    const modelFiles = resolution.useHubCache
+        ? modelCacheEntriesForEngine(localInfer.listModelCache(), engine.id)
+        : modelEntriesForEngine(localInfer.listModelDirectory(modelDirectory), engine.id);
     // The model status checks the selected model against the model directory
     // and probes the hf CLI, so the card shows its Download row (or the URL
     // row) only while the model is absent.
-    const entry = defaultModelFor(engine.id, modelId);
     let modelStatus = null;
     if (entry !== undefined) {
-        const present = existsSync(modelArtifactPath(entry, modelDir));
+        const present = modelArtifactPresent(entry, resolution.baseDir, resolution.useHubCache);
         const hfCli = (await localInfer.hfCliAvailable()) !== null;
         modelStatus = {
             modelId: entry.modelId,
@@ -82,7 +94,7 @@ export async function buildSummary(localInfer, request) {
             url: entry.url,
             present,
             hfCli,
-            downloadCommand: hfDownloadCommand(entry, modelDir),
+            downloadCommand: hfDownloadCommand(entry, modelDirectory, resolution.useHubCache),
         };
     }
     // The chat-template status checks the selected template against the model
@@ -93,14 +105,14 @@ export async function buildSummary(localInfer, request) {
     const chatTemplateValue = typeof config.chatTemplate === 'string' ? config.chatTemplate : '';
     let chatTemplateStatus = null;
     if (isHfRepoReference(chatTemplateValue)) {
-        const present = existsSync(join(modelDir, CHAT_TEMPLATE_FILE));
+        const present = chatTemplatePresent(chatTemplateValue, resolution.baseDir, resolution.useHubCache);
         const hfCli = (await localInfer.hfCliAvailable()) !== null;
         chatTemplateStatus = {
             repo: chatTemplateValue,
             label: chatTemplateLabel(chatTemplateValue),
             present,
             hfCli,
-            downloadCommand: hfChatTemplateCommand(chatTemplateValue, modelDir),
+            downloadCommand: hfChatTemplateCommand(chatTemplateValue, modelDirectory, resolution.useHubCache),
         };
     }
     // The restart re-link: a provider entry whose launch record names a still-
@@ -134,12 +146,17 @@ export async function buildSummary(localInfer, request) {
         status: providerStatuses[provider.id] ?? 'unsure',
         config: provider.config,
         platform: provider.platform,
+        // exactOptionalPropertyTypes: carry the Auto Rebuild flag only when the
+        // stored entry has it, so an entry saved before the key existed carries
+        // no key and the card draws the checkbox unchecked.
+        ...(provider.autoRebuild !== undefined ? { autoRebuild: provider.autoRebuild } : {}),
     }));
     // The "unsure" banner: shown when no provider is confirmed running but at
     // least one reads as unsure (a foreign engine the detector saw but could
-    // not tie to a model, or a busy card). The banner offers bash kill commands
-    // for the engine processes the detector saw holding VRAM, so the user can
-    // stop a provider launched in another session.
+    // not tie to a model, or a busy card). The banner offers the host-OS stop
+    // commands (Stop-Process on Windows, kill on Linux and macOS) for the engine
+    // processes the detector saw holding VRAM, so the user can stop a provider
+    // launched in another session.
     const anyRunning = providers.some((p) => p.status === 'running');
     const anyUnsure = providers.some((p) => p.status === 'unsure');
     const unsureBanner = !anyRunning && anyUnsure
@@ -148,6 +165,12 @@ export async function buildSummary(localInfer, request) {
             killCommands: await localInfer.unsureBannerKillCommands(),
         }
         : null;
+    // The "Unknown Engine(s)" readout shows the VRAM the detector's foreign
+    // engine programs are holding: the OS-reserve segment is the GPU's used
+    // VRAM when a foreign engine is detected, so the readout names the
+    // footprint a provider launched in another session is eating off the
+    // card. Absent when no provider reads as unsure.
+    const unknownEngines = anyUnsure ? { bytes: estimate.breakdown.reserve } : null;
     // The registered flag tells the card whether the current config's provider
     // and model are already in the DSH settings, so the Remove button shows
     // only when there is something to remove. A profile without the settings
@@ -172,8 +195,10 @@ export async function buildSummary(localInfer, request) {
         engines: ENGINES.map((entry) => {
             // The platform defaults ride the engine entry so the card's Engine
             // platform section seeds the build-command and docker-tag placeholders
-            // from the same data the deploy step consumes.
-            const defaults = enginePlatformDefaults(entry.id);
+            // from the same data the deploy step consumes. The build command is the
+            // engine's first build step for the detected host OS, so a Windows host
+            // seeds the vcpkg route and a Linux host seeds the cmake route.
+            const defaults = enginePlatformDefaults(entry.id, hardware.os);
             return {
                 id: entry.id,
                 label: entry.label,
@@ -184,6 +209,7 @@ export async function buildSummary(localInfer, request) {
                 ...(defaults.defaultDockerTag !== undefined
                     ? { defaultDockerTag: defaults.defaultDockerTag }
                     : {}),
+                defaultEngineDirectory: dshEngineCacheDirectory(entry.id),
             };
         }),
         models: localInfer.registeredVramModels().map((model) => ({ id: model.id, source: model.source })),
@@ -193,13 +219,7 @@ export async function buildSummary(localInfer, request) {
         // host-KV slider cap), so the render model and the meter agree on the
         // machine they run on.
         formModel: renderForm(engine.parameters, config, hardware),
-        meterModel: renderMeter(estimate.breakdown, estimate.verdict, hardware.gpu?.vramGiB ?? 0, estimate.source, estimate.reserveSource, 
-        // The "Unknown Engine(s)" readout shows the VRAM the detector's foreign
-        // engine programs are holding: the OS-reserve segment is the GPU's used
-        // VRAM when a foreign engine is detected, so the readout names the
-        // footprint a provider launched in another session is eating off the
-        // card. Absent when no provider reads as unsure.
-        anyUnsure ? { bytes: estimate.breakdown.reserve } : null),
+        meterModel: renderMeter(estimate.breakdown, estimate.verdict, hardware.gpu?.vramGiB ?? 0, estimate.source, estimate.reserveSource, unknownEngines),
         verdict: estimate.verdict,
         warningsModel: renderWarnings(guidelineResults),
         config,
@@ -222,4 +242,4 @@ export async function buildSummary(localInfer, request) {
         registered,
     };
 }
-//# sourceMappingURL=summary.js.map
+//# sourceMappingURL=summary.js.map

package/packages/ui/lib/viewmodels/summaryHelpers.d.ts

@@ -27,4 +27,4 @@ export declare function chatTemplateLabel(repo: string): string;
  * the engine's first default model.
  */
 export declare function resolveModelRegistryId(engineId: string, model: unknown): string;
-//# sourceMappingURL=summaryHelpers.d.ts.map
+//# sourceMappingURL=summaryHelpers.d.ts.map

package/packages/ui/lib/viewmodels/summaryHelpers.js

@@ -39,4 +39,4 @@ export function resolveModelRegistryId(engineId, model) {
     }
     return defaultModelsForEngine(engineId)[0]?.modelId ?? engineId;
 }
-//# sourceMappingURL=summaryHelpers.js.map
+//# sourceMappingURL=summaryHelpers.js.map

package/packages/ui/lib/warnings.d.ts

@@ -53,4 +53,4 @@ export declare function toneFor(level: GuidelineLevel): WarningTone;
  * key so the form renders each warning next to the parameter it names.
  */
 export declare function renderWarnings(results: readonly GuidelineResult[]): WarningsModel;
-//# sourceMappingURL=warnings.d.ts.map
+//# sourceMappingURL=warnings.d.ts.map

package/packages/ui/lib/warnings.js

@@ -66,4 +66,4 @@ export function renderWarnings(results) {
         inline,
     };
 }
-//# sourceMappingURL=warnings.js.map
+//# sourceMappingURL=warnings.js.map

package/packages/ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-local-infer-ui",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Web UI for the dsh local-inference plugin: the form-type-aware parameter form, the live VRAM Est. meter, the red hardware-warning banner, the engine lifecycle controls (build / deploy / stop), and the register-as-model confirmation",
   "keywords": [
     "dsh",
@@ -30,13 +30,13 @@
   },
   "dependencies": {
     "dsh-plugin-local-infer-core": "workspace:^",
-    "dsh-plugin-local-infer-service": "workspace:^",
-    "dsh-plugin-local-infer-providers": "workspace:^"
+    "dsh-plugin-local-infer-providers": "workspace:^",
+    "dsh-plugin-local-infer-service": "workspace:^"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.1"
   },
   "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/cordis": "^4.0.6-alpha.2"
   }
 }

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

@@ -1,53 +0,0 @@
-/**
- * Strata parameter surface. The declarative `ParameterSpec` data for the
- * Strata engine (https://github.com/Niko1221/Strata), sourced from the
- * repository's `docs/AI_SETUP.md` (the `strata launch` flags) and
- * `docs/DOCKER.md` (the container environment variables). Each spec carries
- * both a `toArgv` spelling (the `strata launch` flag the binary and source
- * build modes pass) and a `toEnv` spelling (the container variable the docker
- * mode passes), so the one surface renders every build mode.
- *
- * The data is the surface; the `StrataAdapter` composes it into a `LaunchPlan`.
- * Adding a flag here is a data edit, never an adapter rewire.
- * @module dsh-plugin-local-infer/providers/strata
- */
-import type { Config, EnumOption, ParameterSpec } from 'dsh-plugin-local-infer/core';
-/**
- * The model families Strata serves. `qwen` is the Qwen3.8-Flash-Next family
- * (the default); the others are the size-specific variants the README's
- * Models section names.
- */
-export declare const STRATA_FAMILY_OPTIONS: readonly EnumOption[];
-/**
- * The picture-reader modes. `on` lets the engine pick the CPU reader under a
- * 24 GB card and the GPU reader from 24 GB; `gpu` and `cpu` force a side.
- */
-export declare const STRATA_VISION_OPTIONS: readonly EnumOption[];
-/**
- * The tuning modes. `skip` is the engine default (no tuning run); `quick` is
- * a one-time run of up to about 20 minutes; `thorough` is a longer run.
- */
-export declare const STRATA_TUNE_OPTIONS: readonly EnumOption[];
-/**
- * The access modes. `local` listens on 127.0.0.1 only and needs no key; every
- * other mode makes a key for you, because the server is then reachable beyond
- * this machine.
- */
-export declare const STRATA_ACCESS_OPTIONS: readonly EnumOption[];
-/**
- * The Strata `ParameterSpec` surface, in form order. The `group` field is the
- * form section; specs without a group render under `General`. The `toArgv`
- * spelling is the `strata launch` flag the binary and source-build modes pass;
- * the `toEnv` spelling is the container variable the docker mode passes. A
- * spec with no `toEnv` (access, dataDir) has no docker counterpart, and a spec
- * with no `toArgv` (port) is spelled by the adapter from the value.
- */
-export declare const STRATA_PARAMETERS: readonly ParameterSpec[];
-/**
- * The Strata model key a config carries: the string model value, falling back
- * to an empty string so a bare config renders a plan the engine sizes for the
- * card (the engine picks the model when none is named). A value that names a
- * local artifact file passes through unchanged.
- */
-export declare function strataModelKey(config: Config): string;
-//# sourceMappingURL=strata.d.ts.map