dsh-plugin-local-infer 0.1.2 → 0.1.4

package/packages/ui/lib/config.js

@@ -0,0 +1,251 @@
+/**
+ * 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. A
+ * non-boolean autoRebuild is dropped by the same by-hand-edit rule, so only
+ * a stored true or false reaches the launch skip.
+ */
+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 };
+        if (typeof fields.autoRebuild === 'boolean') {
+            provider.autoRebuild = fields.autoRebuild;
+        }
+        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));
+}
+/**
+ * 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 function writeStored(stored, patch = {}) {
+    const next = { ...stored, ...patch };
+    writeConfig(next.engine, next.config, next.allowRunDeps, next.platform, next.showHelp, next.providers, next.logPath, next.lastLogs);
+}
+/**
+ * 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,11 +56,11 @@ export interface DepsModel {
  */
 export declare function renderDeps(input: {
     engineId: string;
-    buildMode: 'docker' | 'local';
+    buildMode: BuildMode;
     packageManager: string | null;
     checks: DepCheck[];
     installString: string;
     runAllowed: boolean;
     chatTemplate?: ChatTemplateDepModel;
 }): DepsModel;
-//# sourceMappingURL=deps.d.ts.map
+//# sourceMappingURL=deps.d.ts.map

package/packages/ui/lib/deps.js

@@ -36,4 +36,4 @@ export function renderDeps(input) {
     }
     return model;
 }
-//# sourceMappingURL=deps.js.map
+//# sourceMappingURL=deps.js.map

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

@@ -95,4 +95,4 @@ export declare function resolveValue(spec: ParameterSpec, config: Config): unkno
  * that message, which is how the form expresses cross-param gating.
  */
 export declare function renderForm(specs: readonly ParameterSpec[], config: Config, hw?: HardwareProfile): FormModel;
-//# sourceMappingURL=form.d.ts.map
+//# sourceMappingURL=form.d.ts.map

package/packages/ui/lib/form.js

@@ -98,4 +98,4 @@ export function renderForm(specs, config, hw) {
     }
     return { sections };
 }
-//# sourceMappingURL=form.js.map
+//# sourceMappingURL=form.js.map

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

@@ -25,6 +25,12 @@ export { renderDeps } from './deps.ts';
 export type { ChatTemplateDepModel, DepItemModel, DepsModel } from './deps.ts';
 export { renderWarnings, toneFor } from './warnings.ts';
 export type { WarningBannerModel, WarningModel, WarningsModel, WarningTone, } from './warnings.ts';
+export type { StoredPlatformConfig } from './config.ts';
+export type { InstallResponse } from './viewmodels/depsHelpers.ts';
+export type { ChatTemplateStatusModel, LocalInferSummary, ProviderSummaryEntry, } from './viewmodels/summary.ts';
+export type { Config, CustomArg, RegisterResult } from 'dsh-plugin-local-infer/core';
+export type { DownloadResult, LaunchResult } from 'dsh-plugin-local-infer/service';
+export type { LogsStreamEvent } from './routes/logs.ts';
 /**
  * Mount the Web UI. The browser card (dsh/client.js) registers into the
  * Plugins page's `plugins.bundle.config` slot and talks to the settings route
@@ -38,4 +44,4 @@ declare const plugin: {
     apply: typeof apply;
 };
 export default plugin;
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/packages/ui/lib/index.js

@@ -9,6 +9,7 @@
  * from; Phase 8 wires them into one panel with the lifecycle controls.
  * @module dsh-plugin-local-infer/ui
  */
+import { createNodeLifecycleHost } from '../../providers/lib/index.js';
 import { registerLocalInferRoute } from "./route.js";
 export const name = 'local-infer-ui';
 export const inject = ['localInfer'];
@@ -32,7 +33,16 @@ export function apply(ctx) {
     if (typeof ctx.inject === 'function') {
         ctx.inject(['webServer'], (scope) => {
             try {
-                registerLocalInferRoute(scope, localInfer);
+                // The route host is built here (not the bare node default) so its
+                // sudo hook reaches the service: a guarded command whose credential
+                // probe found nothing announces through notifySudoNeeded, and the
+                // launch run's sudo observer (ops/engine.ts) turns it into the
+                // streamed sudo event and the Logs note. The same host drives the
+                // Get and launch routes' Get steps.
+                const host = createNodeLifecycleHost(undefined, {
+                    notify: (command) => localInfer.notifySudoNeeded(command),
+                });
+                registerLocalInferRoute(scope, localInfer, host, host);
             }
             catch (error) {
                 console.error(`[local-infer] settings route skipped: ${error}`);
@@ -42,4 +52,4 @@ export function apply(ctx) {
 }
 const plugin = { name, inject, apply };
 export default plugin;
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

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

@@ -57,4 +57,4 @@ export interface MeterModel {
  * the dark segment's value came from.
  */
 export declare function renderMeter(breakdown: VramBreakdown, verdict: VramVerdict, vramGiB: number, source: 'measured' | 'estimated' | 'not-measured', reserveSource?: ReserveSource, unknownEngines?: UnknownEnginesModel | null): MeterModel;
-//# sourceMappingURL=meter.d.ts.map
+//# sourceMappingURL=meter.d.ts.map

package/packages/ui/lib/meter.js

@@ -40,4 +40,4 @@ export function renderMeter(breakdown, verdict, vramGiB, source, reserveSource =
         unknownEngines,
     };
 }
-//# sourceMappingURL=meter.js.map
+//# sourceMappingURL=meter.js.map

package/packages/ui/lib/ops/engine.d.ts

@@ -0,0 +1,216 @@
+/**
+ * The engine lifecycle operations: launchEngine runs the shared Get-steps
+ * routine (idempotent) and then renders the plan the registered adapter
+ * produces and runs the service's launch entry point (deploy, then the health
+ * poll), preserving the Get-step logs in the persisted last-run logs;
+ * stopEngine stops the exact container or process the launch started (a
+ * re-adopted engine through the record's pid), and a failed stop persists a
+ * note to the last-run logs and the log file; getEngine is a thin wrapper
+ * over the shared Get-steps routine (deps, git sync, build, model download,
+ * chat-template download). The launch record (the engine pid, start time,
+ * launch arguments, and the DSH process pid that launched it) is what a DSH
+ * restart re-links a surviving engine to its config:
+ * relinkStoredProviders re-adopts surviving engines on mount and per summary
+ * read, handleEngineDeath settles the stored state the moment an engine dies
+ * outside the stop path, and persistLaunchLogs stores the captured output.
+ * The platform-config registry sync keeps the service registry in step with
+ * the stored config.
+ * @module dsh-plugin-local-infer/ui/ops/engine
+ */
+import type { Config, LaunchStep, LifecycleHost } from 'dsh-plugin-local-infer/core';
+import type { EngineDeathEvent, LaunchResult, LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { StoredConfig, StoredProviderConfig } from '../config.ts';
+import type { GetRequest, LaunchRequest } from '../request.ts';
+/**
+ * CANCELED_LINE names the shared "Canceled" run line; it lives with the other
+ * run-line constants in ops/logs.ts and is re-exported here for the launch
+ * persisters' import surface.
+ */
+export { CANCELED_LINE } from './logs.ts';
+/**
+ * GET_EVENT_PREFIX leads a Get run's event lines in the streamed and
+ * persisted run (the route's `get failed` line and getEngine's sudo CLI
+ * note), so both read alike and the `!!` marker has one home (routes/get.ts
+ * and getEngine both build it from here).
+ */
+export declare const GET_EVENT_PREFIX = "!! ";
+/**
+ * resolveAdapter picks the registered engine adapter an engine id routes to. A
+ * card that names an engine no adapter serves gets a 404, not a blank panel.
+ */
+export declare function resolveAdapter(localInfer: LocalInferService, engineId: string): import("dsh-plugin-local-infer/core").EngineAdapter;
+/**
+ * resolveStoredRequest resolves a route request's engine and config against
+ * the stored config: the request's fields win, and an absent field falls back
+ * to the stored value, the same rule every route applies. The Get route
+ * reads it for its run-log key before delegating to getEngine.
+ */
+export declare function resolveStoredRequest(request: {
+    engine?: string;
+    config?: Config;
+}): {
+    stored: StoredConfig;
+    engineId: string;
+    config: Config;
+};
+/**
+ * registerSudoObserver registers the run's sudo hook on the service under
+ * the run's key (the hub's own keying) and returns the disposer that removes
+ * only this hook: concurrent runs each keep their own slot, a re-launch
+ * under the same key takes the slot from the older run, and the first settle
+ * never clears another run's note routing. The service hands every guarded
+ * announcement to every registered hook (the shared CLI password wait can
+ * block any run, and the announce seam does not name the triggering run), so
+ * one wait notes every run in flight. launchEngine and getEngine share the
+ * helper so the sudo-note rule has one home: the hook appends noteLine to
+ * the run's own sink (the note rides the streamed run and the run text
+ * persisted when the step settles) and through persistProcessLog (so a run
+ * still hung on the prompt reads the note in the Logs section and the log
+ * file before it settles), then calls onSudo, the route's stream event; a
+ * Get passes none because its control keeps its throbber. The caller invokes
+ * the disposer in a finally so a failed run leaves no hook behind.
+ */
+export declare function registerSudoObserver(localInfer: LocalInferService, runKey: string, noteLine: string, noteTo: (text: string) => void, onSudo?: () => void): () => void;
+/**
+ * launchEngine runs the shared Get-steps routine (idempotent: deps, git sync,
+ * build, model download, chat-template download, each skipped when already
+ * satisfied) and then renders the plan the registered adapter produces for
+ * the config and the detected hardware, and runs the service's launch entry
+ * point (deploy, then the health poll). A git sync of an existing checkout
+ * that fails under the continueOnSyncFailure override (always on for a
+ * launch) keeps the Get run going with the checkout's current version and
+ * reports syncFailed on the result; the launch then threads autoRebuild:
+ * false into the deploy step, which skips its own git sync (it would hit the
+ * same rebase conflict) and launches the current version, while the Get
+ * error line persists in the last-run logs and the log file. The detail the
+ * launch returns names the broken step when the engine does not come up.
+ * The launch line (the
+ * engine binary and its arguments) leads the engine output in the run logs
+ * the card's Logs section and the log file carry, and the Get-step output the
+ * launch ran leads it, so a broken setup diagnoses against the exact steps
+ * and child process the launch started, and the Get logs are preserved, not
+ * wiped, by the launch's persistence. The launch step persists the
+ * launch record (the engine pid, start time, launch arguments, and the DSH
+ * process pid that launched it) on the request's provider entry, so a DSH
+ * restart can re-link a surviving engine to its config. The optional signal
+ * is the card's cancel: an abort interrupts the in-flight Get-step download
+ * child, and the persisted run carries a "Canceled" line. The optional
+ * onChunk is the hf download's raw stderr progress sink: the download runner
+ * hands each streamed chunk to it as it lands, so a launch that runs the Get
+ * steps streams the download progress the same way a Get does. The optional
+ * onSudo is the route's sudo-event writer: while the run is in flight, the
+ * service's sudo observer answers a guarded command waiting for a password on
+ * the launching CLI by landing the core CLI note in the run logs and the log
+ * file and calling onSudo; the observer is unregistered when the run settles,
+ * failed or not, so a failing run leaves none behind. The whole run brackets
+ * one live hub run under the runLogKey rule (the "--- Launching..." seed,
+ * the Get-steps sink, the command note, the deploy and engine output at
+ * settle, end in a finally), so the streaming logs route reads the launch.
+ */
+export declare function launchEngine(localInfer: LocalInferService, request: LaunchRequest, onProgress?: (step: LaunchStep) => void, host?: LifecycleHost, signal?: AbortSignal, onChunk?: (chunk: string) => void, onSudo?: () => void): Promise<LaunchResult>;
+/**
+ * RunLogWriter is the hub slice handleEngineDeath needs: the catch-up read,
+ * the append, and the settle. The LocalInfer service satisfies it, so the
+ * route's observer closure can hand the service itself to the note path.
+ */
+export type RunLogWriter = Pick<LocalInferService, 'readRunLog' | 'appendRunLog' | 'endRun'>;
+/**
+ * handleEngineDeath persists a provider entry's state when its engine process
+ * dies outside the plugin's stop path: a crash, a pkill of a plugin-launched
+ * child seen through the service's exit watch, or the poll-detected exit of a
+ * process adopted after a DSH restart. The entry whose launch record names the
+ * dead pid (or the dead engine-and-port, when the report carries no pid match)
+ * has its record cleared, so a restart never re-links a dead pid, and the exit
+ * line lands in the card's last-run logs beside the engine's own output. An
+ * event that matches no entry carrying a record (a stop the route already
+ * cleared, an engine the plugin never tracked) is a no-op, which keeps an
+ * expected stop quiet. With a run-log hub (the route's observer closure
+ * captures the service), the same note line also lands in the dead entry's
+ * live buffer: the snapshot is read first, and if the run was NOT already
+ * running, the append's lazy reopen is settled with endRun right after, so a
+ * late note streams without stranding the key as running.
+ */
+export declare function handleEngineDeath(event: EngineDeathEvent, runLogs?: RunLogWriter): void;
+/**
+ * persistLaunchLogs stores a launch's captured output as the last run and
+ * writes it to the configured log file. The Get-step output the launch ran
+ * (the optional runText) leads the persisted run, so the Logs section and the
+ * log file show the Get steps followed by the launch, not the launch wiping
+ * the Get logs. The stored last-run logs ride the shared capRunLogs tail rule
+ * (ops/logs.ts), the same cap the append paths and the live hub apply. The
+ * log file is only written when the run produced output and the log location
+ * is set; the last-run logs are always persisted (an empty string clears a
+ * stale run) so the card's Logs section shows the previous run after a
+ * reload.
+ */
+export declare function persistLaunchLogs(result: LaunchResult, engineId: string, config: Config, runText?: string): void;
+/**
+ * stopEngine renders the same plan and runs the service's stop entry point, so
+ * the stop step targets the exact container or process the launch started. The
+ * stop then clears the target entry's launch record (the engine pid and the
+ * previous-pid list with it), so a recycled pid cannot re-link an engine the
+ * user just stopped. An engine a DSH restart re-adopted carries no tracked
+ * child handle in the adapter, so the stop stamps the record's pid on the
+ * plan and the adapter signals it through the host; a stop that fails
+ * persists a note (the engine, the model, and the host's message) to the
+ * stored last-run logs and the log file, so the card's Logs section names the
+ * broken step, and re-throws, so the route answers 500 and the card's stop
+ * deadline settles the entry to the red Logs state.
+ */
+export declare function stopEngine(localInfer: LocalInferService, request: LaunchRequest): Promise<void>;
+/**
+ * relinkStoredProviders prices every stored provider launch record against the
+ * live process table through the service's re-link rule and returns the
+ * provider list the card should read: an adopted engine is re-marked plugin-
+ * launched and tied to its model by the service, and a liveness watcher starts
+ * on its port so a later pkill settles the stored state through the death
+ * observer without another summary read; a dead engine's record is cleared on
+ * disk here (the previous-pid list with it), so a recycled pid cannot re-link
+ * to a config whose engine is down. The route calls it on mount and the
+ * summary calls it per read, making re-attach independent of the card opening.
+ */
+export declare function relinkStoredProviders(localInfer: LocalInferService, stored: StoredConfig): Promise<StoredProviderConfig[]>;
+/**
+ * GetOutcome is the answer the Get step reports: ok with no detail, or a
+ * failure naming the broken step. The object literal union keeps the
+ * invariant the card reads: a detail only exists on a failure.
+ */
+export type GetOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    detail?: string;
+};
+/**
+ * getEngine is the Get step: a thin wrapper over the shared Get-steps routine
+ * (the system dependencies, the git sync, the build, the model download, and
+ * the chat-template download), streaming every step through log as it lands,
+ * so the card appends it to the Logs section live. The dependency install
+ * only runs while the Play/Run trust gate is on; with the gate off the deps
+ * are re-checked and a missing one aborts the step with the copy/paste note.
+ * The optional signal is the card's cancel: an abort interrupts the in-flight
+ * hf download child (SIGINT, then SIGTERM). Resume is within-invocation only:
+ * the hf CLI (huggingface_hub 2.x) resumes a network blip via HTTP Range inside
+ * one `hf download` run, but a killed run re-downloads from zero on the re-run
+ * (each run writes a process-unique `.incomplete` temp blob and unlinks it on
+ * failure), so an orphaned partial blob lingers until `hf cache prune`. The
+ * optional onChunk is the hf download's raw stderr progress sink: the
+ * download runner hands each streamed chunk to it as it lands, separate from
+ * the log sink, so the route parses the tqdm lines into progress events. The
+ * run registers the same sudo observer a launch does: a guarded command
+ * waiting for the user's password on the launching CLI writes the core CLI
+ * note through log as a GET_EVENT_PREFIX line, the same marker the route's
+ * own failure line uses, so the note rides the streamed run and the run text
+ * the route persists, and through persistProcessLog so a run still hung on
+ * the prompt reads it before it settles. The Get control keeps its throbber,
+ * so the observer announces nothing beyond the note line.
+ */
+export declare function getEngine(localInfer: LocalInferService, request: GetRequest, log: (chunk: string) => void, host?: LifecycleHost, signal?: AbortSignal, onChunk?: (chunk: string) => void): Promise<GetOutcome>;
+/**
+ * syncPlatformConfigs re-syncs the service registry with the stored platform
+ * map: it registers (or re-registers) every engine that carries a config, and
+ * unregisters every engine that no longer does, so a launch always reads the
+ * platform config the user last saved.
+ */
+export declare function syncPlatformConfigs(localInfer: LocalInferService, stored: StoredConfig): void;
+//# sourceMappingURL=engine.d.ts.map