dsh-plugin-local-infer 0.1.2 → 0.1.4

package/packages/service/lib/launch-target.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The stored provider entry a launch, stop, or run-log write targets. The
+ * rule the ui's launch-record paths carried privately moves here so the
+ * record persistence and the run-log key rule share one matcher.
+ * @module dsh-plugin-local-infer/service/launch-target
+ */
+import type { Config } from 'dsh-plugin-local-infer/core';
+import type { LaunchTargetEntry } from './types.ts';
+/**
+ * findLaunchTarget resolves the stored provider entry a launch, stop, or
+ * run targets: the entry the request names by id, or (an id the card does
+ * not send, a launch of the active config) the stored entry with the same
+ * engine and model. A request with no resolvable entry reads as undefined,
+ * which the launch-record paths take as "no provider config to re-link" and
+ * the run-log key rule takes as "key on the engine id". The entry type
+ * stays generic so each caller keeps its own stored entry shape.
+ */
+export declare function findLaunchTarget<T extends LaunchTargetEntry>(providers: readonly T[], engineId: string, providerId: string | undefined, config: Config): T | undefined;
+//# sourceMappingURL=launch-target.d.ts.map

package/packages/service/lib/launch-target.js

@@ -0,0 +1,28 @@
+/**
+ * The stored provider entry a launch, stop, or run-log write targets. The
+ * rule the ui's launch-record paths carried privately moves here so the
+ * record persistence and the run-log key rule share one matcher.
+ * @module dsh-plugin-local-infer/service/launch-target
+ */
+/**
+ * findLaunchTarget resolves the stored provider entry a launch, stop, or
+ * run targets: the entry the request names by id, or (an id the card does
+ * not send, a launch of the active config) the stored entry with the same
+ * engine and model. A request with no resolvable entry reads as undefined,
+ * which the launch-record paths take as "no provider config to re-link" and
+ * the run-log key rule takes as "key on the engine id". The entry type
+ * stays generic so each caller keeps its own stored entry shape.
+ */
+export function findLaunchTarget(providers, engineId, providerId, config) {
+    if (providerId !== undefined) {
+        const byId = providers.find((entry) => entry.id === providerId);
+        if (byId !== undefined)
+            return byId;
+    }
+    const model = typeof config.model === 'string' ? config.model : undefined;
+    if (model === undefined)
+        return undefined;
+    return providers.find((entry) => entry.engine === engineId &&
+        (typeof entry.config.model === 'string' ? entry.config.model : undefined) === model);
+}
+//# sourceMappingURL=launch-target.js.map

package/packages/service/lib/run-logs.d.ts

@@ -0,0 +1,72 @@
+/**
+ * The per-key live run-log hub: one bounded buffer per run key with fan-out
+ * to subscribers, so every provider process (Get, Launch, Prereqs, Download,
+ * Install, Stop) writes its output to one place the streaming web route
+ * serves. The LocalInfer facade publishes the five operations (begin,
+ * append, read, subscribe, end); runLogKey names the key rule every caller
+ * shares.
+ * @module dsh-plugin-local-infer/service/run-logs
+ */
+import type { Config } from 'dsh-plugin-local-infer/core';
+import type { LaunchTargetEntry, RunLogListener, RunLogSnapshot } from './types.ts';
+/**
+ * RunLogStore holds one RunBuffer per run key and fans RunLogEvents out to
+ * the key's subscribers. A throwing listener is isolated per notify, so a
+ * broken stream connection never blocks a writer or another subscriber.
+ */
+export declare class RunLogStore {
+    private readonly buffers;
+    /**
+     * begin resets the key's buffer to the seed line, restarts the seq at 0,
+     * marks the run running, and notifies subscribers with the reset event so
+     * a mid-run attached reader replaces its display instead of appending
+     * onto the previous run.
+     */
+    begin(key: string, seed: string): void;
+    /**
+     * append grows the key's text (tail-capped to LOG_TAIL_BYTES, the same
+     * rule the stored last-run logs use), counts the append, and notifies
+     * subscribers with the chunk. A key with no open run opens one lazily
+     * without a seed, and an append to a settled run reopens it, so a note
+     * that lands after the run (an engine-death line) still streams; the
+     * caller that opens a run this way closes it with its own end.
+     */
+    append(key: string, chunk: string): void;
+    /**
+     * read answers the key's catch-up snapshot. A key that never ran reads as
+     * an empty stopped snapshot.
+     */
+    read(key: string): RunLogSnapshot;
+    /**
+     * subscribe registers a listener for the key's events and returns the
+     * disposer. Registering the same function twice delivers once (Set
+     * semantics); each connection registers its own closure.
+     */
+    subscribe(key: string, listener: RunLogListener): () => void;
+    /**
+     * end clears the running flag and emits the end event; the text stays
+     * readable until the next begin. A key with no open run is a no-op, so a
+     * repeated end never emits a second end event.
+     */
+    end(key: string): void;
+    /**
+     * bufferFor reads the key's buffer, starting an empty stopped one for a
+     * key that has none.
+     */
+    private bufferFor;
+    /**
+     * notify hands one event to each listener of one buffer. It iterates a
+     * copy so a disposer running inside a listener cannot disturb the pass,
+     * and it swallows listener throws: a broken connection must never fail
+     * the writer.
+     */
+    private notify;
+}
+/**
+ * runLogKey names the run key every run path and the logs route share, so
+ * the client can always predict the key for its request: the request's
+ * providerId when it names one, else the stored entry findLaunchTarget
+ * matches by engine and model, else the engine id.
+ */
+export declare function runLogKey(providers: readonly LaunchTargetEntry[], engineId: string, providerId: string | undefined, config: Config): string;
+//# sourceMappingURL=run-logs.d.ts.map

package/packages/service/lib/run-logs.js

@@ -0,0 +1,125 @@
+/**
+ * The per-key live run-log hub: one bounded buffer per run key with fan-out
+ * to subscribers, so every provider process (Get, Launch, Prereqs, Download,
+ * Install, Stop) writes its output to one place the streaming web route
+ * serves. The LocalInfer facade publishes the five operations (begin,
+ * append, read, subscribe, end); runLogKey names the key rule every caller
+ * shares.
+ * @module dsh-plugin-local-infer/service/run-logs
+ */
+import { LOG_TAIL_BYTES } from '../../core/lib/index.js';
+import { findLaunchTarget } from "./launch-target.js";
+/**
+ * RunLogStore holds one RunBuffer per run key and fans RunLogEvents out to
+ * the key's subscribers. A throwing listener is isolated per notify, so a
+ * broken stream connection never blocks a writer or another subscriber.
+ */
+export class RunLogStore {
+    buffers = new Map();
+    /**
+     * begin resets the key's buffer to the seed line, restarts the seq at 0,
+     * marks the run running, and notifies subscribers with the reset event so
+     * a mid-run attached reader replaces its display instead of appending
+     * onto the previous run.
+     */
+    begin(key, seed) {
+        const buffer = this.bufferFor(key);
+        buffer.text = seed;
+        buffer.seq = 0;
+        buffer.running = true;
+        this.notify(buffer, { kind: 'reset', seq: 0, text: seed });
+    }
+    /**
+     * append grows the key's text (tail-capped to LOG_TAIL_BYTES, the same
+     * rule the stored last-run logs use), counts the append, and notifies
+     * subscribers with the chunk. A key with no open run opens one lazily
+     * without a seed, and an append to a settled run reopens it, so a note
+     * that lands after the run (an engine-death line) still streams; the
+     * caller that opens a run this way closes it with its own end.
+     */
+    append(key, chunk) {
+        const buffer = this.bufferFor(key);
+        buffer.text += chunk;
+        if (buffer.text.length > LOG_TAIL_BYTES) {
+            buffer.text = buffer.text.slice(-LOG_TAIL_BYTES);
+        }
+        buffer.running = true;
+        buffer.seq += 1;
+        this.notify(buffer, { kind: 'log', seq: buffer.seq, text: chunk });
+    }
+    /**
+     * read answers the key's catch-up snapshot. A key that never ran reads as
+     * an empty stopped snapshot.
+     */
+    read(key) {
+        const buffer = this.buffers.get(key);
+        if (buffer === undefined)
+            return { seq: 0, text: '', running: false };
+        return { seq: buffer.seq, text: buffer.text, running: buffer.running };
+    }
+    /**
+     * subscribe registers a listener for the key's events and returns the
+     * disposer. Registering the same function twice delivers once (Set
+     * semantics); each connection registers its own closure.
+     */
+    subscribe(key, listener) {
+        const buffer = this.bufferFor(key);
+        buffer.listeners.add(listener);
+        return () => {
+            buffer.listeners.delete(listener);
+        };
+    }
+    /**
+     * end clears the running flag and emits the end event; the text stays
+     * readable until the next begin. A key with no open run is a no-op, so a
+     * repeated end never emits a second end event.
+     */
+    end(key) {
+        const buffer = this.buffers.get(key);
+        if (buffer === undefined || !buffer.running)
+            return;
+        buffer.running = false;
+        this.notify(buffer, { kind: 'end', seq: buffer.seq });
+    }
+    /**
+     * bufferFor reads the key's buffer, starting an empty stopped one for a
+     * key that has none.
+     */
+    bufferFor(key) {
+        let buffer = this.buffers.get(key);
+        if (buffer === undefined) {
+            buffer = { text: '', seq: 0, running: false, listeners: new Set() };
+            this.buffers.set(key, buffer);
+        }
+        return buffer;
+    }
+    /**
+     * notify hands one event to each listener of one buffer. It iterates a
+     * copy so a disposer running inside a listener cannot disturb the pass,
+     * and it swallows listener throws: a broken connection must never fail
+     * the writer.
+     */
+    notify(buffer, event) {
+        for (const listener of [...buffer.listeners]) {
+            try {
+                listener(event);
+            }
+            catch {
+                // The connection is broken; its own route tears it down.
+            }
+        }
+    }
+}
+/**
+ * runLogKey names the run key every run path and the logs route share, so
+ * the client can always predict the key for its request: the request's
+ * providerId when it names one, else the stored entry findLaunchTarget
+ * matches by engine and model, else the engine id.
+ */
+export function runLogKey(providers, engineId, providerId, config) {
+    if (providerId !== undefined && providerId.trim() !== '')
+        return providerId;
+    const target = findLaunchTarget(providers, engineId, undefined, config);
+    return target?.id ?? engineId;
+}
+//# sourceMappingURL=run-logs.js.map

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, CommandLogger, CommandOutcome, CommandRunner, Config, DefaultModel, ModelCacheEntry, 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
@@ -92,7 +93,11 @@ export interface LaunchResult {
  * (on) or is written to the card's Logs section (off). `autoRebuild` is the
  * card's "Auto Rebuild" checkbox: when false, the deploy step skips the git
  * sync (fetch, rebase, rebuild) and launches the checkout as-is. Absent reads
- * as true (the rebuild runs).
+ * as true (the rebuild runs). `onLog` is the launch run's log sink: the
+ * deploy step writes the `$ <command>` line of every mutating command it runs
+ * (image pull, model download) through it before the child spawns, and the
+ * health poll (these options ride straight into the adapter's HealthCheckOptions)
+ * writes its `> GET <healthUrl>` line and settled verdict through it.
  */
 export interface LaunchOptions {
     pollMs?: number;
@@ -100,6 +105,7 @@ export interface LaunchOptions {
     onProgress?: LaunchProgress;
     allowRunDeps?: boolean;
     autoRebuild?: boolean;
+    onLog?: CommandLogger;
 }
 /**
  * RegisterModelOptions tunes the model registration: agentDefault points the
@@ -109,6 +115,18 @@ export interface LaunchOptions {
 export interface RegisterModelOptions {
     agentDefault?: boolean;
 }
+/**
+ * RunInstallOptions tunes the Play/Run install: `onLog` is the install run's
+ * log sink, and the service writes each command the runner is about to
+ * execute as a `$ <command>` line through it before the child spawns, so the
+ * run reads command first and per-dep results after. `runner` injects the
+ * command runner, so a test captures the command lines without spawning a
+ * real shell (the way downloadModel injects its download runner).
+ */
+export interface RunInstallOptions {
+    onLog?: CommandLogger;
+    runner?: CommandRunner;
+}
 /**
  * FetchPresetResult is the answer to a mod-search preset fetch: the tagged
  * preset when the bridge fetched and extracted it, a storage flag, and a
@@ -148,9 +166,27 @@ export interface DownloadResult {
 /**
  * DownloadModelOptions tunes the model download: runner injects the command
  * runner, so a test captures the rendered hf CLI command without a live hf.
+ * onChunk is the callback the runner hands each streamed stdout and stderr
+ * chunk to, so the card's Logs pane reads the hf CLI's progress live while a
+ * long download runs. useHubCache selects the hub-cache layout (no
+ * `--local-dir`, the `models--{ns}--{name}` directories) when the model
+ * directory is the plugin default; a user-overridden directory keeps the flat
+ * `--local-dir` target. signal is the card's cancel: an abort interrupts the
+ * in-flight hf child (SIGINT, then SIGTERM). Resume is within-invocation only
+ * (the hf CLI resumes a network blip via HTTP Range inside one run); a killed
+ * run re-downloads from zero on the re-run, and the orphaned `.incomplete`
+ * blob lingers until `hf cache prune`.
+ * onLog is the run's log-text sink: the service writes the rendered command's
+ * `$ <hf download ...>` line through it before the runner spawns the child,
+ * so every download path (Get step, launch, download route) logs the command
+ * exactly once, from the exec site, ahead of its output.
  */
 export interface DownloadModelOptions {
-    runner?: (command: string) => Promise<CommandOutcome>;
+    runner?: (command: string, signal?: AbortSignal, onChunk?: (chunk: string) => void) => Promise<CommandOutcome>;
+    onChunk?: (chunk: string) => void;
+    onLog?: CommandLogger;
+    useHubCache?: boolean;
+    signal?: AbortSignal;
 }
 /**
  * SettingsNamespaceDescriptor is the structural view of one profile plugin
@@ -209,6 +245,71 @@ export interface SettingsForms {
     }): Promise<SettingsDescribeAnswer>;
     mutate(ns: string, ops: readonly SettingsOp[], expectedRevision?: number): Promise<SettingsRemoteResponse<unknown> | undefined>;
 }
+/**
+ * LaunchTargetEntry is the stored provider entry shape findLaunchTarget
+ * reads: the entry id, the engine id, and the config whose model field the
+ * engine-and-model match prices. The ui store's StoredProviderConfig
+ * satisfies it structurally, so the matcher stays free of the store shape.
+ */
+export interface LaunchTargetEntry {
+    id: string;
+    engine: string;
+    config: Config;
+}
+/**
+ * RunLogSnapshot is the catch-up read of one run key's live log: the append
+ * count reached (the `seq` every later stream event continues), the bounded
+ * tail text (LOG_TAIL_BYTES), and whether a run is still writing. A mid-run
+ * page refresh or a late-opened Logs pane renders from this snapshot and
+ * then follows the live events, so it shows the same text a continuously
+ * attached reader has.
+ */
+export interface RunLogSnapshot {
+    seq: number;
+    text: string;
+    running: boolean;
+}
+/**
+ * RunLogResetEvent announces a beginRun for the subscribed key: the buffer
+ * restarted at the seed text with seq 0, so a reader replaces its display
+ * instead of appending onto the previous run's text.
+ */
+export interface RunLogResetEvent {
+    kind: 'reset';
+    seq: number;
+    text: string;
+}
+/**
+ * RunLogAppendEvent carries one live log append: `text` is the appended
+ * chunk (not the buffer), and `seq` is the buffer's append count after the
+ * chunk landed, so a reader that caught up from a snapshot can drop events
+ * it already holds.
+ */
+export interface RunLogAppendEvent {
+    kind: 'log';
+    seq: number;
+    text: string;
+}
+/**
+ * RunLogEndEvent announces endRun for the subscribed key: the run stopped
+ * writing at `seq`. The text stays readable (readRunLog) until the next
+ * beginRun for that key.
+ */
+export interface RunLogEndEvent {
+    kind: 'end';
+    seq: number;
+}
+/**
+ * RunLogEvent is one live update on a subscribed run key: the buffer reset
+ * by a begin, one appended chunk, or the run's end.
+ */
+export type RunLogEvent = RunLogResetEvent | RunLogAppendEvent | RunLogEndEvent;
+/**
+ * RunLogListener receives a subscribed key's RunLogEvents. Listeners are
+ * independent per connection: a throwing or removed listener never blocks
+ * the writer or another subscriber.
+ */
+export type RunLogListener = (event: RunLogEvent) => void;
 /**
  * LocalInferService is the surface the service publishes on ctx.localInfer.
  * Providers register engines, presets, and guidelines against the registries;
@@ -239,11 +340,11 @@ 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, options?: RunInstallOptions): Promise<InstallResult>;
     launch(plan: LaunchPlan, options?: LaunchOptions): Promise<LaunchResult>;
-    stop(plan: LaunchPlan): Promise<void>;
+    stop(plan: LaunchPlan, log?: CommandLogger): Promise<void>;
     reLinkProviders(entries: readonly {
         id: string;
         record: ProviderLaunchRecord;
@@ -258,15 +359,72 @@ export interface LocalInferService {
      * clears it, which the route's effect does on dispose.
      */
     setEngineDeathObserver(observer: ((event: EngineDeathEvent) => void) | undefined): void;
+    /**
+     * registerSudoObserver reserves `key`'s slot (the runLogKey rule every run
+     * path shares) for the callback one run registers to hear that a sudo
+     * command is waiting for the user's password on the CLI: the observer
+     * writes the note line into its own run's Logs so the card user learns
+     * where the prompt landed. Registering a key that is taken replaces the
+     * old hook, and the returned disposer removes only its own hook, so
+     * concurrent runs never clobber each other's note routing and a settle
+     * never clears another run's slot.
+     */
+    registerSudoObserver(key: string, observer: (command: string) => void): () => void;
+    /**
+     * notifySudoNeeded is the seam a command runner reports a waiting sudo
+     * prompt through: a guarded runner calls it when its probe finds no cached
+     * credentials, and the service forwards the command to every observer the
+     * runs registered (the shared CLI password wait can block any run, and
+     * the announce seam does not name the triggering run). No observer, or a
+     * throwing one, never fails the run that is already racing the sudo
+     * deadline.
+     */
+    notifySudoNeeded(command: string): void;
+    /**
+     * beginRun starts one provider process's run under `key` (the runLogKey
+     * rule every run path shares): the live buffer resets to the `seed` line
+     * (the `--- <process>...` separator), the running flag goes true, the
+     * monotone seq restarts, and subscribers get a reset notice so a mid-run
+     * attached reader replaces rather than appends.
+     */
+    beginRun(key: string, seed: string): void;
+    /**
+     * appendRunLog appends one chunk to `key`'s live buffer (tail-capped to
+     * LOG_TAIL_BYTES) and notifies subscribers with the chunk. Appending with
+     * no open run opens one lazily without a seed, so a note that lands after
+     * a settled run (an engine-death line, for example) still reaches the
+     * Logs.
+     */
+    appendRunLog(key: string, text: string): void;
+    /**
+     * readRunLog answers `key`'s catch-up snapshot (mid-run page refresh,
+     * late pane open): the seq reached, the bounded tail text, and the
+     * running flag. A key that never ran reads as an empty stopped snapshot.
+     */
+    readRunLog(key: string): RunLogSnapshot;
+    /**
+     * subscribeRunLog registers a listener for `key`'s RunLogEvents (appends,
+     * run begin, run end) and returns the disposer. Listeners are independent
+     * per connection; a slow or closed connection never blocks a writer.
+     */
+    subscribeRunLog(key: string, listener: RunLogListener): () => void;
+    /**
+     * endRun clears `key`'s running flag and emits the end event. The text
+     * stays readable (readRunLog) until the next beginRun for that key. An
+     * end on a key with no open run is a no-op.
+     */
+    endRun(key: string): void;
     registerModel(plan: LaunchPlan, model: ModelRow, options?: RegisterModelOptions): Promise<RegisterResult>;
     removeModel(providerId: string, modelId: string): Promise<void>;
     resolveDefaults(engineId: string, modelId: string, hw: HardwareProfile, explicit?: Config): Promise<ResolvedDefaults>;
     fetchPreset(source: PresetSource, options?: FetchPresetOptions): Promise<FetchPresetResult>;
     defaultModelDirectory(): string;
+    defaultDatasetDirectory(): string;
     hfCliAvailable(options?: HfCliOptions): Promise<string | null>;
     downloadModel(entry: DefaultModel, directory: string, options?: DownloadModelOptions): Promise<DownloadResult>;
     downloadChatTemplate(repo: string, directory: string, options?: DownloadModelOptions): Promise<DownloadResult>;
     modelIsRegistered(providerId: string, modelId: string): Promise<boolean>;
     listModelDirectory(directory: string): ModelDirectoryEntry[];
+    listModelCache(): ModelCacheEntry[];
 }
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=types.d.ts.map

package/packages/service/lib/types.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/packages/service/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-local-infer-service",
-  "version": "0.1.0",
+  "version": "0.1.4",
   "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",
@@ -36,6 +36,6 @@
     "@deepseek-ai/cordis": ">=4.0.1"
   },
   "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/cordis": "^4.0.6-alpha.2"
   }
 }

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

@@ -24,4 +24,4 @@ declare const plugin: {
     apply: typeof apply;
 };
 export default plugin;
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/packages/tool/lib/index.js

@@ -22,4 +22,4 @@ export function apply(ctx) {
 }
 const plugin = { name, inject, apply };
 export default plugin;
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/packages/tool/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-local-infer-tool",
-  "version": "0.1.0",
+  "version": "0.1.4",
   "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",
@@ -36,6 +36,6 @@
     "@deepseek-ai/cordis": ">=4.0.1"
   },
   "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1"
+    "@deepseek-ai/cordis": "^4.0.6-alpha.2"
   }
 }

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

@@ -0,0 +1,89 @@
+/**
+ * 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, the per-provider Auto Rebuild flag the card's checkbox
+ * stores, 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;
+    autoRebuild?: boolean;
+    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;
+/**
+ * writeStored persists a read StoredConfig with a patch over one or more of
+ * its fields, leaving every unpatched field as the read returned it. The
+ * eight stored fields travel as one value through the ops, so a caller names
+ * only the field it changes (the providers list, the last-run logs) instead
+ * of re-passing every field the read returned.
+ */
+export declare function writeStored(stored: StoredConfig, patch?: Partial<StoredConfig>): 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