dsh-plugin-local-infer 0.1.2 → 0.1.3

package/packages/providers/lib/platform.js

@@ -5,7 +5,9 @@
  * defaults are a data edit here, never a card rewire.
  * @module dsh-plugin-local-infer/providers/platform
  */
-import { LLAMACPP_DOCKER_IMAGE, NINFER_DOCKER_IMAGE, STRATA_DOCKER_IMAGE, } from "./adapters.js";
+import { LLAMACPP_DOCKER_IMAGE } from "./engines/llamacppAdapter.js";
+import { NINFER_DOCKER_IMAGE } from "./engines/ninferAdapter.js";
+import { STRATA_DOCKER_IMAGE } from "./engines/strataAdapter.js";
 import { engineBuildSteps } from "./acquire.js";
 // The local build command is the engine's first acquisition build step (the
 // cmake build the deploy step runs in the checkout), read through
@@ -15,6 +17,7 @@ import { engineBuildSteps } from "./acquire.js";
 const NINFER_BUILD_COMMAND = engineBuildSteps('ninfer')[0];
 const LLAMACPP_BUILD_COMMAND = engineBuildSteps('llamacpp')[0];
 const INFERNIX_BUILD_COMMAND = engineBuildSteps('infernix')[0];
+const STRATA_BUILD_COMMAND = engineBuildSteps('strata')[0];
 /**
  * The per-engine platform defaults, keyed by engine id. The build command is
  * the engine's first acquisition build step; the docker tag is the upstream
@@ -45,6 +48,9 @@ export const ENGINE_PLATFORM_DEFAULTS = {
             : {}),
     },
     strata: {
+        ...(STRATA_BUILD_COMMAND !== undefined
+            ? { defaultBuildCommand: STRATA_BUILD_COMMAND }
+            : {}),
         defaultDockerTag: STRATA_DOCKER_IMAGE,
     },
 };

package/packages/providers/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-local-infer-providers",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Concrete providers for the dsh local-inference plugin: the ninfer, hyperqwen, llamacpp, and strata engine adapters, the NInfer VramModel, the built-in presets, the built-in guidelines, and the per-OS SystemDep install command data. Each registers itself with ctx.localInfer.",
   "keywords": [
     "dsh",

package/packages/service/lib/index.d.ts

@@ -18,7 +18,7 @@
  * @module dsh-plugin-local-infer/service
  */
 import { Context, Service } from '@deepseek-ai/cordis';
-import type { Config, DefaultModel, ModelDirectoryEntry, EngineAdapter, EngineDepPlan, EnginePlatformConfig, GpuUsageProbe, Guideline, GuidelineResult, HardwareProfile, HardwareProbes, InstallResult, LaunchPlan, ModelRow, Preset, PresetSource, ProcessLine, ProviderLaunchRecord, ProviderRef, ProviderStatus, ReLinkOutcome, RegisterResult, ReserveResolution, ResolvedDefaults, SystemDep, VramModel } from 'dsh-plugin-local-infer/core';
+import type { BuildMode, Config, DefaultModel, ModelDirectoryEntry, EngineAdapter, EngineDepPlan, EnginePlatformConfig, GpuUsageProbe, Guideline, GuidelineResult, HardwareProfile, HardwareProbes, InstallResult, LaunchPlan, ModelRow, Preset, PresetSource, ProcessLine, ProviderLaunchRecord, ProviderRef, ProviderStatus, ReLinkOutcome, RegisterResult, ReserveResolution, ResolvedDefaults, SystemDep, VramModel } from 'dsh-plugin-local-infer/core';
 import type { DetectOsReserveOptions, DownloadModelOptions, DownloadResult, EngineDeathEvent, EstimateResult, FetchPresetOptions, FetchPresetResult, HfCliOptions, LaunchOptions, LaunchResult, LocalInferService, ProviderStatusOptions, RegisterModelOptions } from './types.ts';
 export type { DetectOsReserveOptions, DownloadModelOptions, DownloadResult, EngineDeathEvent, EstimateResult, FetchPresetOptions, FetchPresetResult, HfCliOptions, LaunchOptions, LaunchResult, LocalInferService, ProviderStatusOptions, RegisterModelOptions, SettingsDescribeResult, SettingsForms, SettingsNamespaceDescriptor, } from './types.ts';
 declare module '@deepseek-ai/cordis' {
@@ -53,6 +53,8 @@ export declare class LocalInfer extends Service implements LocalInferService {
     private readonly launchedPorts;
     private readonly engineWatchers;
     private readonly handledPids;
+    private readonly launchingEngines;
+    private readonly stoppingEngines;
     private deathObserver;
     constructor(ctx: Context);
     registerEngine(adapter: EngineAdapter): () => void;
@@ -168,19 +170,19 @@ export declare class LocalInfer extends Service implements LocalInferService {
      * registered plan for the engine id is the fallback, and an engine with
      * neither plans an empty list (nothing to install, the gate passes).
      */
-    deps(engineId: string, buildMode: 'docker' | 'local', hw: HardwareProfile): Promise<readonly SystemDep[]>;
+    deps(engineId: string, buildMode: BuildMode, hw: HardwareProfile): Promise<readonly SystemDep[]>;
     /**
      * installString renders the copy/paste block for the resolved dep plan,
      * keyed to the detected package manager, with the by-hand note for a dep
      * the manager has no commands for.
      */
-    installString(engineId: string, buildMode: 'docker' | 'local', hw: HardwareProfile): Promise<string>;
+    installString(engineId: string, buildMode: BuildMode, hw: HardwareProfile): Promise<string>;
     /**
      * runInstall is the Play/Run path: it runs the resolved dep plan's commands
      * through the shell runner and re-probes each dep. The runner captures the
      * per-command exit, so a failure names the command that broke.
      */
-    runInstall(engineId: string, buildMode: 'docker' | 'local', hw: HardwareProfile): Promise<InstallResult>;
+    runInstall(engineId: string, buildMode: BuildMode, hw: HardwareProfile): Promise<InstallResult>;
     /**
      * launch is the lifecycle entry point: it resolves the adapter that rendered
      * the plan (by the plan's engineId), runs the adapter's deploy step (build
@@ -238,6 +240,13 @@ export declare class LocalInfer extends Service implements LocalInferService {
      * record dead.
      */
     private watchAdoptedEngine;
+    /**
+     * engineKey is the in-flight state machine's key for one engine: the engine
+     * id plus its port when the plan names one, so two configs of one engine on
+     * different ports are distinct engines. A plan with no port keys on the
+     * engine id alone.
+     */
+    private engineKey;
     /**
      * stopEngineWatcher cancels one port's adopted-process poll, if it has one.
      */

package/packages/service/lib/index.js

@@ -94,6 +94,20 @@ export class LocalInfer extends Service {
     // handle. A summary re-link that adopts this DSH's own launch record must
     // not stack a poll watcher on top of the handle's close event.
     handledPids = new Set();
+    // The engine keys (engineId:port) whose launch this service is in flight
+    // for: the deploy has started and the health poll has not settled. While a
+    // key is here the provider-status detector keeps the provider's linked read
+    // (running, not unsure), so an engine that sizes its own model (Strata, no
+    // model tie) or a launch mid-poll never flashes the "Unable to link" banner.
+    // The key clears when the launch settles (a healthy poll, a failed deploy).
+    launchingEngines = new Set();
+    // The engine keys (engineId:port) whose stop this service is in flight for:
+    // the stop step signalled the engine and the process has not died yet. While
+    // a key is here the detector keeps the linked read, so a stop never reads as
+    // an unlinked provider for the moment the engine takes to shut down. The key
+    // clears when the process dies (the death observer) or the detector sees the
+    // process down (a stop of an engine it cannot watch).
+    stoppingEngines = new Set();
     // The route-registered hook for engine process deaths (a crash, a pkill, or
     // a poll-detected death of an adopted process). The observer persists the
     // provider entry's cleared state; a headless profile registers none and the
@@ -352,7 +366,29 @@ export class LocalInfer extends Service {
             const port = signatures[index]?.port;
             return port !== undefined ? { ...provider, port } : provider;
         });
-        return computeProviderStatuses({ providers: priced, running, gpuBusy: isGpuBusy(gpuUsage) });
+        const statuses = computeProviderStatuses({ providers: priced, running, gpuBusy: isGpuBusy(gpuUsage) });
+        // The in-flight launch and stop state machine: a provider the launch or
+        // stop step is in flight for keeps its linked read (running, not unsure)
+        // while the engine process is still up, so neither a stop (the record is
+        // cleared but the process is still shutting down) nor a launch (an engine
+        // that sizes its own model carries no model tie) flashes the "Unable to
+        // link" banner. A stopped provider whose process is down reads as stopped,
+        // and the stopping flag clears with it, so a stop of an engine the service
+        // cannot watch (no death event) never leaves a stale flag behind.
+        for (const provider of priced) {
+            const key = this.engineKey(provider.engine, provider.port);
+            const launching = this.launchingEngines.has(key);
+            const stopping = this.stoppingEngines.has(key);
+            if (!launching && !stopping)
+                continue;
+            if (statuses[provider.id] === 'unsure') {
+                statuses[provider.id] = 'running';
+            }
+            else if (stopping) {
+                this.stoppingEngines.delete(key);
+            }
+        }
+        return statuses;
     }
     /**
      * unsureBannerKillCommands returns the bash kill commands for the engine
@@ -472,8 +508,16 @@ export class LocalInfer extends Service {
                 ...(options?.autoRebuild !== undefined ? { autoRebuild: options.autoRebuild } : {}),
             }
             : undefined;
+        // The in-flight launch flag: the provider-status detector keeps this
+        // provider's linked read while the deploy and health poll run, so an engine
+        // that sizes its own model (no model tie) never flashes "Unable to link".
+        const launchKey = this.engineKey(plan.engineId, plan.port);
+        this.launchingEngines.add(launchKey);
         const deployResult = await adapter.deploy(plan, platform, onProgress, deployOptions);
         if (!deployResult.ok) {
+            // A failed deploy settles the launch: clear the in-flight flag so the
+            // provider reads from the process state (stopped), not a stuck launch.
+            this.launchingEngines.delete(launchKey);
             // exactOptionalPropertyTypes: only write the detail key when it is present.
             const result = { plan, healthy: false };
             if (deployResult.detail !== undefined) {
@@ -517,10 +561,20 @@ export class LocalInfer extends Service {
         // "Launching..." while it waits for the engine to report ready.
         onProgress?.('launch');
         const health = await adapter.healthCheck(plan, options);
+        // The launch has settled (a healthy poll, a failed one, or a download that
+        // the card re-polls): clear the in-flight flag so the provider reads from
+        // the model tie (a healthy launch) or the process state (a failed one).
+        this.launchingEngines.delete(launchKey);
         const launchResult = { plan, healthy: health.healthy };
         if (health.detail !== undefined) {
             launchResult.detail = health.detail;
         }
+        // The start phase the poll observed (downloading, starting, ready, failed)
+        // rides the result so the card reads a long model download as in progress
+        // instead of a broken launch.
+        if (health.state !== undefined) {
+            launchResult.state = health.state;
+        }
         // The launch record the route persists for the provider config entry: the
         // engine's pid and the DSH process pid that launched it. The parent pid is
         // only written when the host process identifies as DSH, so a non-DSH host
@@ -671,6 +725,15 @@ export class LocalInfer extends Service {
         timer.unref();
         this.engineWatchers.set(port, { pid: record.pid, timer });
     }
+    /**
+     * engineKey is the in-flight state machine's key for one engine: the engine
+     * id plus its port when the plan names one, so two configs of one engine on
+     * different ports are distinct engines. A plan with no port keys on the
+     * engine id alone.
+     */
+    engineKey(engineId, port) {
+        return port !== undefined ? `${engineId}:${port}` : engineId;
+    }
     /**
      * stopEngineWatcher cancels one port's adopted-process poll, if it has one.
      */
@@ -693,6 +756,10 @@ export class LocalInfer extends Service {
      */
     observeEngineDeath(event) {
         if (event.port !== undefined) {
+            // The process is down: the in-flight stop (if one was in flight) has
+            // settled, so drop the flag and the deferred port-to-model tie the stop
+            // step kept for the provider's linked read.
+            this.stoppingEngines.delete(this.engineKey(event.engineId, event.port));
             const tracked = this.launchedModels.get(event.port);
             if (tracked !== undefined && tracked.engineId === event.engineId) {
                 this.launchedModels.delete(event.port);
@@ -722,12 +789,19 @@ export class LocalInfer extends Service {
         if (adapter === undefined) {
             throw new LocalInferError(`no engine adapter is registered for "${plan.engineId}"`, 'LOCAL_INFER_INVALID_ENGINE');
         }
+        // The in-flight stop flag: the provider-status detector keeps this
+        // provider's linked read while the engine shuts down, so a stop never
+        // flashes the "Unable to link" banner for the moment the process takes to
+        // die. The flag clears when the process dies (the death observer) or the
+        // detector sees the process down (a stop of an engine it cannot watch).
+        this.stoppingEngines.add(this.engineKey(plan.engineId, plan.port));
         await adapter.stop(plan);
-        // Clear the port-to-model entry too, so the provider-status detector no
-        // longer ties this port to the model the plugin launched it with, and
-        // cancel any adopted-process watcher standing on the port.
+        // Clear the live-port ledger and the plugin-launched flag, and cancel any
+        // adopted-process watcher standing on the port. The port-to-model tie is
+        // deferred to the death observer, so the provider keeps its linked read
+        // (running, not unsure) for the moment the engine is still shutting down;
+        // the observer drops it the instant the process is down.
         if (plan.port !== undefined) {
-            this.launchedModels.delete(plan.port);
             this.stopEngineWatcher(plan.port);
             const ports = this.launchedPorts.get(plan.engineId);
             if (ports !== undefined) {

package/packages/service/lib/types.d.ts

@@ -1,4 +1,4 @@
-import type { CommandOutcome, Config, DefaultModel, ModelDirectoryEntry, EngineAdapter, EngineDepPlan, EnginePlatformConfig, Guideline, GuidelineResult, GpuUsageProbe, HardwareProfile, InstallResult, LaunchPlan, LaunchProgress, ModelRow, Preset, PresetSource, ProcessLine, ProviderLaunchRecord, ProviderRef, ProviderStatus, ReLinkOutcome, RegisterResult, ReserveResolution, ReserveSource, ResolvedDefaults, SettingsOp, SystemDep, VramBreakdown, VramModel, VramVerdict } from 'dsh-plugin-local-infer/core';
+import type { BuildMode, CommandOutcome, Config, DefaultModel, ModelDirectoryEntry, EngineAdapter, EngineDepPlan, EngineLaunchState, EnginePlatformConfig, Guideline, GuidelineResult, GpuUsageProbe, HardwareProfile, InstallResult, LaunchPlan, LaunchProgress, ModelRow, Preset, PresetSource, ProcessLine, ProviderLaunchRecord, ProviderRef, ProviderStatus, ReLinkOutcome, RegisterResult, ReserveResolution, ReserveSource, ResolvedDefaults, SettingsOp, SystemDep, VramBreakdown, VramModel, VramVerdict } from 'dsh-plugin-local-infer/core';
 /**
  * EstimateResult is the answer to an estimate call: the full VRAM breakdown,
  * the one-word verdict the meter renders, the source the numbers came from,
@@ -79,6 +79,7 @@ export interface LaunchResult {
     buildLogs?: string;
     pid?: number;
     parentPid?: number;
+    state?: EngineLaunchState;
 }
 /**
  * LaunchOptions tunes the launch health poll: the interval between attempts
@@ -239,9 +240,9 @@ export interface LocalInferService {
         gpuUsage?: GpuUsageProbe | null;
     }): Promise<string[]>;
     guidelines(config: Config, hw: HardwareProfile, engineId?: string): Promise<GuidelineResult[]>;
-    deps(engineId: string, buildMode: 'docker' | 'local', hw: HardwareProfile): Promise<readonly SystemDep[]>;
-    installString(engineId: string, buildMode: 'docker' | 'local', hw: HardwareProfile): Promise<string>;
-    runInstall(engineId: string, buildMode: 'docker' | 'local', hw: HardwareProfile): Promise<InstallResult>;
+    deps(engineId: string, buildMode: BuildMode, hw: HardwareProfile): Promise<readonly SystemDep[]>;
+    installString(engineId: string, buildMode: BuildMode, hw: HardwareProfile): Promise<string>;
+    runInstall(engineId: string, buildMode: BuildMode, hw: HardwareProfile): Promise<InstallResult>;
     launch(plan: LaunchPlan, options?: LaunchOptions): Promise<LaunchResult>;
     stop(plan: LaunchPlan): Promise<void>;
     reLinkProviders(entries: readonly {

package/packages/service/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-local-infer-service",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Service Definition for the dsh local-inference capability seam (ctx.localInfer): the engine, preset, and guideline registries plus the orchestration entry points (estimate, guidelines, deps, installString, runInstall, launch, registerModel). Carries no store of its own.",
   "keywords": [
     "dsh",

package/packages/tool/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-local-infer-tool",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Model-facing tools for the dsh local-inference plugin: local_infer_estimate, local_infer_launch, local_infer_status, and local_infer_register, each on its own timeout budget, plus the system-prompt section that tells the agent when to use them",
   "keywords": [
     "dsh",

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

@@ -0,0 +1,79 @@
+/**
+ * The stored-config persistence the routes and ops share. The values live in
+ * ~/.dsh/local-infer/config.json, shared with the CLI, so the browser never
+ * sees a secret it did not store. Every read sanitizes the file field by
+ * field, so a by-hand edit never poisons the deploy step or the re-link rule.
+ * @module dsh-plugin-local-infer/ui/config
+ */
+import type { Config, ProviderLaunchRecord } from 'dsh-plugin-local-infer/core';
+/**
+ * The config file the route owns. It sits under the dsh home so a web user and
+ * a CLI user share one file, the way modsearch shares ~/.modsearch.
+ */
+export declare function localInferConfigPath(): string;
+/**
+ * StoredPlatformConfig is the per-engine platform config the deploy step
+ * consumes (§3.10): where the engine platform lives locally and the git repo
+ * that overrides the engine's default upstream. The map is keyed by engine id,
+ * so the stored entry carries no id of its own; the route adds it when it
+ * builds the EnginePlatformConfig the service registry stores.
+ */
+export interface StoredPlatformConfig {
+    engineDirectory?: string;
+    engineFork?: string;
+    buildCommands?: string;
+    dockerTag?: string;
+}
+/**
+ * StoredProviderConfig is one saved provider model+engine config the card
+ * lists: a stable id the card edits and deletes against, the engine and the
+ * full parameter config it serves, the per-engine platform config the deploy
+ * step consumes, and the launch record the launch step persists when it
+ * starts the entry's engine (the engine pid, start time, launch arguments,
+ * and the DSH process pid that launched it). The record is what a DSH
+ * restart re-links a surviving engine to its config; a stop clears it.
+ */
+export interface StoredProviderConfig {
+    id: string;
+    engine: string;
+    config: Config;
+    platform: StoredPlatformConfig;
+    launch?: ProviderLaunchRecord;
+}
+export interface StoredConfig {
+    engine: string;
+    config: Config;
+    allowRunDeps: boolean;
+    platform: Record<string, StoredPlatformConfig>;
+    showHelp: boolean;
+    providers: StoredProviderConfig[];
+    logPath: string;
+    lastLogs: string;
+}
+/**
+ * readConfig reads the stored engine, config, trust gate, and per-engine
+ * platform configs. A missing or broken file reads as the scaffold default
+ * (NInfer, empty config, gate off, no platform configs) so the card always has
+ * a form to draw. A platform entry that is not an object (or whose fields are
+ * not strings) is dropped, so a by-hand edit never poisons the deploy step.
+ */
+export declare function readConfig(): StoredConfig;
+/**
+ * writeConfig persists the engine, config, trust gate, per-engine platform
+ * configs, and the help toggle, creating the directory tree on first write.
+ */
+export declare function writeConfig(engine: string, config: Config, allowRunDeps: boolean, platform?: Record<string, StoredPlatformConfig>, showHelp?: boolean, providers?: StoredProviderConfig[], logPath?: string, lastLogs?: string): void;
+/**
+ * parsePlatformConfigs reads the stored platform map, keeping only entries
+ * whose fields are strings. A non-object map or a non-object entry reads as
+ * absent, so the deploy step never sees a platform config it cannot price.
+ */
+export declare function parsePlatformConfigs(raw: unknown): Record<string, StoredPlatformConfig>;
+/**
+ * parseStoredPlatformConfig reads one engine's platform config (the launch
+ * request's `platform` key), keeping only string fields. A non-object or an
+ * object with no string fields reads as absent, so the launch keeps the stored
+ * entry the save route synced.
+ */
+export declare function parseStoredPlatformConfig(raw: unknown): StoredPlatformConfig | undefined;
+//# sourceMappingURL=config.d.ts.map

package/packages/ui/lib/config.js

@@ -0,0 +1,235 @@
+/**
+ * The stored-config persistence the routes and ops share. The values live in
+ * ~/.dsh/local-infer/config.json, shared with the CLI, so the browser never
+ * sees a secret it did not store. Every read sanitizes the file field by
+ * field, so a by-hand edit never poisons the deploy step or the re-link rule.
+ * @module dsh-plugin-local-infer/ui/config
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+// Relative, not the root package subpath: a self-referencing bare specifier
+// only resolves when the package sits inside a node_modules tree, so a
+// local-path or pnpm-linked install of this repo would fail the import.
+import { DEFAULT_LOG_PATH_TEMPLATE } from '../../core/lib/index.js';
+/**
+ * The config file the route owns. It sits under the dsh home so a web user and
+ * a CLI user share one file, the way modsearch shares ~/.modsearch.
+ */
+export function localInferConfigPath() {
+    return join(homedir(), '.dsh', 'local-infer', 'config.json');
+}
+/**
+ * readConfig reads the stored engine, config, trust gate, and per-engine
+ * platform configs. A missing or broken file reads as the scaffold default
+ * (NInfer, empty config, gate off, no platform configs) so the card always has
+ * a form to draw. A platform entry that is not an object (or whose fields are
+ * not strings) is dropped, so a by-hand edit never poisons the deploy step.
+ */
+export function readConfig() {
+    const path = localInferConfigPath();
+    if (!existsSync(path)) {
+        return {
+            engine: 'ninfer',
+            config: {},
+            allowRunDeps: false,
+            platform: {},
+            showHelp: true,
+            providers: [],
+            logPath: DEFAULT_LOG_PATH_TEMPLATE,
+            lastLogs: '',
+        };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return {
+            engine: typeof parsed.engine === 'string' ? parsed.engine : 'ninfer',
+            config: parsed.config && typeof parsed.config === 'object' ? parsed.config : {},
+            allowRunDeps: typeof parsed.allowRunDeps === 'boolean' ? parsed.allowRunDeps : false,
+            platform: parsePlatformConfigs(parsed.platform),
+            // A file that predates the key (or carries a non-boolean) reads as
+            // descriptions visible, the default the card draws on first open.
+            showHelp: typeof parsed.showHelp === 'boolean' ? parsed.showHelp : true,
+            providers: parseProviders(parsed.providers),
+            // A file that predates the key reads as the plugin's default log dir,
+            // and the last-run logs start empty until a launch fills them.
+            logPath: typeof parsed.logPath === 'string' && parsed.logPath !== ''
+                ? parsed.logPath
+                : DEFAULT_LOG_PATH_TEMPLATE,
+            lastLogs: typeof parsed.lastLogs === 'string' ? parsed.lastLogs : '',
+        };
+    }
+    catch {
+        return {
+            engine: 'ninfer',
+            config: {},
+            allowRunDeps: false,
+            platform: {},
+            showHelp: true,
+            providers: [],
+            logPath: DEFAULT_LOG_PATH_TEMPLATE,
+            lastLogs: '',
+        };
+    }
+}
+/**
+ * parseProviders reads the stored provider list, keeping only entries with a
+ * non-blank string id. A non-object entry or an entry with no id is dropped,
+ * so a by-hand edit never poisons the card's provider list. The per-engine
+ * platform config is read through the same string-field rule the platform map
+ * uses, so a provider never carries a platform field it cannot price.
+ */
+function parseProviders(raw) {
+    if (raw === null || typeof raw !== 'object' || !Array.isArray(raw)) {
+        return [];
+    }
+    const providers = [];
+    for (const entry of raw) {
+        if (entry === null || typeof entry !== 'object' || Array.isArray(entry))
+            continue;
+        const fields = entry;
+        if (typeof fields.id !== 'string' || fields.id.trim() === '')
+            continue;
+        const engine = typeof fields.engine === 'string' ? fields.engine : 'ninfer';
+        const config = fields.config && typeof fields.config === 'object' ? fields.config : {};
+        const platform = parseStoredPlatformConfig(fields.platform) ?? {};
+        const provider = { id: fields.id, engine, config, platform };
+        const launch = parseLaunchRecord(fields.launch);
+        if (launch !== undefined) {
+            provider.launch = launch;
+        }
+        providers.push(provider);
+    }
+    return providers;
+}
+/**
+ * parseLaunchRecord reads one stored launch record, keeping only the fields
+ * the re-link rule prices (the engine pid, the start time, the argv, the
+ * parent and previous pids, and the engine/model/port the detector ties the
+ * engine to). A record that is not an object, or that names no integer pid
+ * or engine id, is dropped, so a by-hand edit never poisons the re-link.
+ */
+function parseLaunchRecord(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const fields = raw;
+    if (typeof fields.pid !== 'number' || !Number.isInteger(fields.pid)) {
+        return undefined;
+    }
+    if (typeof fields.startedAt !== 'string' || fields.startedAt === '') {
+        return undefined;
+    }
+    if (typeof fields.engineId !== 'string' || fields.engineId.trim() === '') {
+        return undefined;
+    }
+    const record = {
+        pid: fields.pid,
+        startedAt: fields.startedAt,
+        argv: Array.isArray(fields.argv)
+            ? fields.argv.filter((part) => typeof part === 'string')
+            : [],
+        previousPids: Array.isArray(fields.previousPids)
+            ? fields.previousPids.filter((part) => typeof part === 'number')
+            : [],
+        engineId: fields.engineId,
+    };
+    if (typeof fields.parentPid === 'number') {
+        record.parentPid = fields.parentPid;
+    }
+    if (typeof fields.modelId === 'string' && fields.modelId !== '') {
+        record.modelId = fields.modelId;
+    }
+    if (typeof fields.port === 'number') {
+        record.port = fields.port;
+    }
+    return record;
+}
+/**
+ * writeConfig persists the engine, config, trust gate, per-engine platform
+ * configs, and the help toggle, creating the directory tree on first write.
+ */
+export function writeConfig(engine, config, allowRunDeps, platform, showHelp, providers, logPath, lastLogs) {
+    const path = localInferConfigPath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify({
+        engine,
+        config,
+        allowRunDeps,
+        platform: platform ?? {},
+        showHelp: showHelp ?? true,
+        providers: providers ?? [],
+        logPath: logPath ?? DEFAULT_LOG_PATH_TEMPLATE,
+        lastLogs: lastLogs ?? '',
+    }, null, 2));
+}
+/**
+ * parsePlatformConfigs reads the stored platform map, keeping only entries
+ * whose fields are strings. A non-object map or a non-object entry reads as
+ * absent, so the deploy step never sees a platform config it cannot price.
+ */
+export function parsePlatformConfigs(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+        return {};
+    }
+    const platform = {};
+    for (const [engineId, entry] of Object.entries(raw)) {
+        if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) {
+            continue;
+        }
+        const stored = {};
+        const fields = entry;
+        if (typeof fields.engineDirectory === 'string') {
+            stored.engineDirectory = fields.engineDirectory;
+        }
+        if (typeof fields.engineFork === 'string') {
+            stored.engineFork = fields.engineFork;
+        }
+        if (typeof fields.buildCommands === 'string') {
+            stored.buildCommands = fields.buildCommands;
+        }
+        if (typeof fields.dockerTag === 'string') {
+            stored.dockerTag = fields.dockerTag;
+        }
+        if (stored.engineDirectory !== undefined ||
+            stored.engineFork !== undefined ||
+            stored.buildCommands !== undefined ||
+            stored.dockerTag !== undefined) {
+            platform[engineId] = stored;
+        }
+    }
+    return platform;
+}
+/**
+ * parseStoredPlatformConfig reads one engine's platform config (the launch
+ * request's `platform` key), keeping only string fields. A non-object or an
+ * object with no string fields reads as absent, so the launch keeps the stored
+ * entry the save route synced.
+ */
+export function parseStoredPlatformConfig(raw) {
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+        return undefined;
+    }
+    const fields = raw;
+    const stored = {};
+    if (typeof fields.engineDirectory === 'string') {
+        stored.engineDirectory = fields.engineDirectory;
+    }
+    if (typeof fields.engineFork === 'string') {
+        stored.engineFork = fields.engineFork;
+    }
+    if (typeof fields.buildCommands === 'string') {
+        stored.buildCommands = fields.buildCommands;
+    }
+    if (typeof fields.dockerTag === 'string') {
+        stored.dockerTag = fields.dockerTag;
+    }
+    if (stored.engineDirectory === undefined &&
+        stored.engineFork === undefined &&
+        stored.buildCommands === undefined &&
+        stored.dockerTag === undefined) {
+        return undefined;
+    }
+    return stored;
+}
+//# sourceMappingURL=config.js.map

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

@@ -7,7 +7,7 @@
  * here.
  * @module dsh-plugin-local-infer/ui/deps
  */
-import type { DepCheck, DepStatus } from 'dsh-plugin-local-infer/core';
+import type { BuildMode, DepCheck, DepStatus } from 'dsh-plugin-local-infer/core';
 /**
  * DepItemModel is one row of the panel's dep list: the dep id, the purpose
  * the user reads, the current status, and whether installing it needs sudo.
@@ -40,7 +40,7 @@ export interface ChatTemplateDepModel {
  */
 export interface DepsModel {
     engineId: string;
-    buildMode: 'docker' | 'local';
+    buildMode: BuildMode;
     packageManager: string | null;
     deps: DepItemModel[];
     allSatisfied: boolean;
@@ -56,7 +56,7 @@ export interface DepsModel {
  */
 export declare function renderDeps(input: {
     engineId: string;
-    buildMode: 'docker' | 'local';
+    buildMode: BuildMode;
     packageManager: string | null;
     checks: DepCheck[];
     installString: string;