dsh-plugin-local-infer 0.1.2 → 0.1.3

package/packages/ui/lib/ops/hf.js

@@ -0,0 +1,60 @@
+/**
+ * The hf CLI download operations: downloadFor runs the download for a default
+ * model, and chatTemplateDownloadFor pulls a selected chat template into the
+ * model directory. Both resolve the directory against the request, the
+ * stored config, and the plugin's default model directory in that order.
+ * @module dsh-plugin-local-infer/ui/ops/hf
+ */
+import { defaultModelFor } from '../../../providers/lib/index.js';
+import { readConfig } from "../config.js";
+import { RouteError } from "../route.js";
+import { isHfRepoReference } from "../viewmodels/summaryHelpers.js";
+/**
+ * downloadFor runs the hf CLI download for the request's default model: it
+ * resolves the entry through the providers' default list (a 404 when no
+ * entry names the pair), resolves the directory against the request, the
+ * stored config, and the plugin's default model directory in that order, and
+ * runs the download through the service.
+ */
+export async function downloadFor(localInfer, request) {
+    const stored = readConfig();
+    const engineId = request.engine ?? stored.engine;
+    const modelId = request.model ?? (typeof stored.config.model === 'string' ? stored.config.model : '');
+    const entry = defaultModelFor(engineId, modelId);
+    if (entry === undefined) {
+        throw new RouteError(404, `no default model is registered for "${engineId}/${modelId}"`);
+    }
+    const storedDir = stored.config.modelDirectory;
+    const directory = typeof request.directory === 'string' && request.directory.trim() !== ''
+        ? request.directory
+        : typeof storedDir === 'string' && storedDir.trim() !== ''
+            ? storedDir
+            : localInfer.defaultModelDirectory();
+    return localInfer.downloadModel(entry, directory);
+}
+/**
+ * chatTemplateDownloadFor runs the hf CLI download for the request's chat
+ * template: it resolves the template repo reference from the request or the
+ * stored config's chatTemplate (a 400 when neither names an HF repo
+ * reference), resolves the directory against the request, the stored config,
+ * and the plugin's default model directory in that order, and runs the
+ * download through the service.
+ */
+export async function chatTemplateDownloadFor(localInfer, request) {
+    const stored = readConfig();
+    let template = typeof request.template === 'string' ? request.template : '';
+    if (template.trim() === '') {
+        template = typeof stored.config.chatTemplate === 'string' ? stored.config.chatTemplate : '';
+    }
+    if (!isHfRepoReference(template)) {
+        throw new RouteError(400, `the chat template must be an HF repo reference, got "${template || '(none)'}"`);
+    }
+    const storedDir = stored.config.modelDirectory;
+    const directory = typeof request.directory === 'string' && request.directory.trim() !== ''
+        ? request.directory
+        : typeof storedDir === 'string' && storedDir.trim() !== ''
+            ? storedDir
+            : localInfer.defaultModelDirectory();
+    return localInfer.downloadChatTemplate(template, directory);
+}
+//# sourceMappingURL=hf.js.map

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

@@ -0,0 +1,23 @@
+/**
+ * The last-run log persistence the card's process steps use: appendProcessLog
+ * appends one run's output (a Get's commands and output, a model download's
+ * result) to the stored last-run logs (the card's Logs section shows it after a
+ * reload) and writes the run to the configured log file, the same per-run file
+ * rule the launch step applies. persistGetLogs and persistDownloadLog are the
+ * step-specific wrappers.
+ * @module dsh-plugin-local-infer/ui/ops/logs
+ */
+/**
+ * persistGetLogs appends one Get run's streamed output (the commands and their
+ * output) to the stored last-run logs and writes the run to the configured log
+ * file, the same per-run file rule the launch step applies.
+ */
+export declare function persistGetLogs(output: string): void;
+/**
+ * persistDownloadLog appends one model or chat-template download's result to the
+ * stored last-run logs and writes the run to the configured log file, so the
+ * card's Logs section and the log file show the download beside the Get and
+ * launch runs.
+ */
+export declare function persistDownloadLog(output: string): void;
+//# sourceMappingURL=logs.d.ts.map

package/packages/ui/lib/ops/logs.js

@@ -0,0 +1,58 @@
+/**
+ * The last-run log persistence the card's process steps use: appendProcessLog
+ * appends one run's output (a Get's commands and output, a model download's
+ * result) to the stored last-run logs (the card's Logs section shows it after a
+ * reload) and writes the run to the configured log file, the same per-run file
+ * rule the launch step applies. persistGetLogs and persistDownloadLog are the
+ * step-specific wrappers.
+ * @module dsh-plugin-local-infer/ui/ops/logs
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname } from 'node:path';
+import { resolveLogPath } from '../../../core/lib/index.js';
+import { readConfig, writeConfig } from "../config.js";
+/**
+ * appendProcessLog appends one process run's output to the stored last-run logs
+ * (capped to the launch logs' tail, so a long build cannot grow the config
+ * without bound) and writes the run to the configured log file. A missing log
+ * location (the field is optional) skips the file, the same rule the launch step
+ * uses. An empty output is a no-op.
+ */
+function appendProcessLog(output) {
+    if (output === '')
+        return;
+    const stored = readConfig();
+    const joined = `${stored.lastLogs}${stored.lastLogs === '' ? '' : '\n'}${output}`;
+    writeConfig(stored.engine, stored.config, stored.allowRunDeps, stored.platform, stored.showHelp, stored.providers, stored.logPath, joined.slice(-65536));
+    if (stored.logPath === undefined || stored.logPath === '')
+        return;
+    const modelId = typeof stored.config.model === 'string' ? stored.config.model : undefined;
+    const logPath = resolveLogPath(stored.logPath, stored.engine, modelId, new Date(), homedir());
+    try {
+        mkdirSync(dirname(logPath), { recursive: true });
+        writeFileSync(logPath, output);
+    }
+    catch {
+        // A log file that cannot be written (a read-only dir, a bad path) must not
+        // fail the run; the in-memory last-run logs still reach the card.
+    }
+}
+/**
+ * persistGetLogs appends one Get run's streamed output (the commands and their
+ * output) to the stored last-run logs and writes the run to the configured log
+ * file, the same per-run file rule the launch step applies.
+ */
+export function persistGetLogs(output) {
+    appendProcessLog(output);
+}
+/**
+ * persistDownloadLog appends one model or chat-template download's result to the
+ * stored last-run logs and writes the run to the configured log file, so the
+ * card's Logs section and the log file show the download beside the Get and
+ * launch runs.
+ */
+export function persistDownloadLog(output) {
+    appendProcessLog(output);
+}
+//# sourceMappingURL=logs.js.map

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

@@ -0,0 +1,79 @@
+/**
+ * The DSH model registration operations: registerFor upserts the provider
+ * and model through the settings seam, unregisterFor removes the exact entry
+ * the registration wrote, and syncRegisteredModel re-runs the registration on
+ * a save so the registered model's input types stay in step with the config.
+ * resolveModelRow and resolveContextWindow resolve the row and context window
+ * the registrar publishes; resolveModelDirectory picks the model directory a
+ * Get run downloads into.
+ * @module dsh-plugin-local-infer/ui/ops/model
+ */
+import type { Config, ModelRow, RegisterResult, VramModel } from 'dsh-plugin-local-infer/core';
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { RegisterRequest } from '../request.ts';
+/**
+ * resolveContextWindow picks the context window the registrar publishes: the
+ * config's maxContext when it names one, else the native ceiling of the
+ * VramModel the config resolves to (the named model, or the single
+ * registered model), else the 32768 spec default. The DSH contextWindow must
+ * not promise a context the engine cannot serve, so the ceiling is the
+ * model's own, not an optimistic number.
+ */
+export declare function resolveContextWindow(config: Config, models: readonly VramModel[]): number;
+/**
+ * resolveModelRow picks the model row the registrar publishes for an engine
+ * and config: the adapter's discovered model (what the running engine
+ * advertises on its model endpoint, read live) when the adapter discovers
+ * one, else the adapter's static modelRef, else the plan's model id, else the
+ * engine id. The display name follows the same fall-through. The discovery
+ * step awaits a terminal query, so the row is resolved asynchronously; an
+ * engine that is down discovers nothing and falls back through modelRef, so
+ * register, save-sync, unregister, and the summary flag stay consistent with
+ * whatever the engine answers while it is up.
+ */
+export declare function resolveModelRow(adapter: {
+    id: string;
+    modelRef?(config: Config): {
+        id: string;
+        name: string;
+    } | undefined;
+    discoverModel?(config: Config): Promise<{
+        id: string;
+        name: string;
+    } | undefined>;
+}, plan: {
+    modelId?: string;
+}, config: Config): Promise<ModelRow>;
+/**
+ * registerFor renders the plan through the registered adapter, resolves the
+ * model row and the context window, and runs the service's register entry
+ * point, which upserts the provider and model through the settings seam.
+ * The result carries the entry the registrar wrote, so the card names the
+ * model it published.
+ */
+export declare function registerFor(localInfer: LocalInferService, request?: RegisterRequest): Promise<RegisterResult>;
+/**
+ * syncRegisteredModel re-runs the registration for a saved config when the
+ * model is already registered in the DSH settings, so the registered model's
+ * input types (the vision flag) stay in step with the saved config. A model
+ * that is not registered (a fresh save) is a no-op, and a profile without the
+ * settings seam throws, which the save route catches and swallows so the save
+ * itself never fails on a sync that cannot run.
+ */
+export declare function syncRegisteredModel(localInfer: LocalInferService, engine: string, config: Config): Promise<void>;
+/**
+ * unregisterFor runs the service's removeModel entry point for the engine's
+ * provider and the model row the register step resolved, so the removal
+ * targets the exact entry the registration wrote.
+ */
+export declare function unregisterFor(localInfer: LocalInferService, request?: RegisterRequest): Promise<{
+    removed: boolean;
+}>;
+/**
+ * resolveModelDirectory picks the model directory a Get run downloads into:
+ * the config's modelDirectory override when it names a path, else the
+ * plugin's default model directory. The same rule the summary and deps routes
+ * apply, so a Get and the card's Model Directory field agree on the target.
+ */
+export declare function resolveModelDirectory(localInfer: LocalInferService, config: Config): string;
+//# sourceMappingURL=model.d.ts.map

package/packages/ui/lib/ops/model.js

@@ -0,0 +1,130 @@
+/**
+ * The DSH model registration operations: registerFor upserts the provider
+ * and model through the settings seam, unregisterFor removes the exact entry
+ * the registration wrote, and syncRegisteredModel re-runs the registration on
+ * a save so the registered model's input types stay in step with the config.
+ * resolveModelRow and resolveContextWindow resolve the row and context window
+ * the registrar publishes; resolveModelDirectory picks the model directory a
+ * Get run downloads into.
+ * @module dsh-plugin-local-infer/ui/ops/model
+ */
+import { buildModelEntry, providerIdFor } from '../../../core/lib/index.js';
+import { readConfig } from "../config.js";
+import { resolveAdapter } from "./engine.js";
+/**
+ * resolveContextWindow picks the context window the registrar publishes: the
+ * config's maxContext when it names one, else the native ceiling of the
+ * VramModel the config resolves to (the named model, or the single
+ * registered model), else the 32768 spec default. The DSH contextWindow must
+ * not promise a context the engine cannot serve, so the ceiling is the
+ * model's own, not an optimistic number.
+ */
+export function resolveContextWindow(config, models) {
+    const configured = config.maxContext;
+    if (typeof configured === 'number' && configured > 0) {
+        return configured;
+    }
+    let model;
+    if (typeof config.model === 'string') {
+        model = models.find((entry) => entry.id === config.model);
+    }
+    else if (models.length === 1) {
+        model = models[0];
+    }
+    return model?.nativeMaxContext ?? 32768;
+}
+/**
+ * resolveModelRow picks the model row the registrar publishes for an engine
+ * and config: the adapter's discovered model (what the running engine
+ * advertises on its model endpoint, read live) when the adapter discovers
+ * one, else the adapter's static modelRef, else the plan's model id, else the
+ * engine id. The display name follows the same fall-through. The discovery
+ * step awaits a terminal query, so the row is resolved asynchronously; an
+ * engine that is down discovers nothing and falls back through modelRef, so
+ * register, save-sync, unregister, and the summary flag stay consistent with
+ * whatever the engine answers while it is up.
+ */
+export async function resolveModelRow(adapter, plan, config) {
+    const ref = (await adapter.discoverModel?.(config)) ?? adapter.modelRef?.(config);
+    const id = ref?.id ?? plan.modelId ?? adapter.id;
+    return { id, name: ref?.name ?? id, contextWindow: 0 };
+}
+/**
+ * registerFor renders the plan through the registered adapter, resolves the
+ * model row and the context window, and runs the service's register entry
+ * point, which upserts the provider and model through the settings seam.
+ * The result carries the entry the registrar wrote, so the card names the
+ * model it published.
+ */
+export async function registerFor(localInfer, request) {
+    const stored = readConfig();
+    const engineId = request?.engine ?? stored.engine;
+    const config = request?.config ?? stored.config;
+    const adapter = resolveAdapter(localInfer, engineId);
+    const hardware = await localInfer.detectHardware();
+    const plan = adapter.renderLaunch(config, hardware);
+    const row = await resolveModelRow(adapter, plan, config);
+    row.contextWindow = resolveContextWindow(config, localInfer.registeredVramModels());
+    // The adapter's declared modalities publish the input types on the DSH
+    // model row (Strata's vision enum, on by default, declares ['text',
+    // 'image']); an adapter that declares none keeps the boolean vision flag: a
+    // vision engine advertises ['text', 'image'] and a text-only engine
+    // ['text']. The registrar copies it into the entry it writes.
+    row.input =
+        adapter.modelInput?.(config) ?? (config.vision === true ? ['text', 'image'] : ['text']);
+    const options = request?.agentDefault === true ? { agentDefault: true } : undefined;
+    return localInfer.registerModel(plan, row, options);
+}
+/**
+ * syncRegisteredModel re-runs the registration for a saved config when the
+ * model is already registered in the DSH settings, so the registered model's
+ * input types (the vision flag) stay in step with the saved config. A model
+ * that is not registered (a fresh save) is a no-op, and a profile without the
+ * settings seam throws, which the save route catches and swallows so the save
+ * itself never fails on a sync that cannot run.
+ */
+export async function syncRegisteredModel(localInfer, engine, config) {
+    const adapter = resolveAdapter(localInfer, engine);
+    const hardware = await localInfer.detectHardware();
+    const plan = adapter.renderLaunch(config, hardware);
+    const row = await resolveModelRow(adapter, plan, config);
+    const buildMode = plan.kind === 'docker' ? 'docker' : 'local';
+    const providerId = providerIdFor(adapter.id, row.id, buildMode);
+    if (await localInfer.modelIsRegistered(providerId, row.id)) {
+        await registerFor(localInfer, { engine, config });
+    }
+}
+/**
+ * unregisterFor runs the service's removeModel entry point for the engine's
+ * provider and the model row the register step resolved, so the removal
+ * targets the exact entry the registration wrote.
+ */
+export async function unregisterFor(localInfer, request) {
+    const stored = readConfig();
+    const engineId = request?.engine ?? stored.engine;
+    const config = request?.config ?? stored.config;
+    const adapter = resolveAdapter(localInfer, engineId);
+    const hardware = await localInfer.detectHardware();
+    const plan = adapter.renderLaunch(config, hardware);
+    const row = await resolveModelRow(adapter, plan, config);
+    // The removal must target the exact entry the register step wrote, so the
+    // provider id is computed through buildModelEntry (the same function the
+    // register step uses) rather than a parallel providerIdFor call, which
+    // could drift if plan.engineId and adapter.id ever diverge.
+    const entry = buildModelEntry(plan, row);
+    await localInfer.removeModel(entry.providerId, row.id);
+    return { removed: true };
+}
+/**
+ * resolveModelDirectory picks the model directory a Get run downloads into:
+ * the config's modelDirectory override when it names a path, else the
+ * plugin's default model directory. The same rule the summary and deps routes
+ * apply, so a Get and the card's Model Directory field agree on the target.
+ */
+export function resolveModelDirectory(localInfer, config) {
+    const rawModelDir = config.modelDirectory;
+    return typeof rawModelDir === 'string' && rawModelDir.trim() !== ''
+        ? rawModelDir
+        : localInfer.defaultModelDirectory();
+}
+//# sourceMappingURL=model.js.map

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

@@ -0,0 +1,106 @@
+/**
+ * The request types the card's routes parse and the parsers that build them.
+ * Every request carries only the keys the card sent: absent values fall back
+ * to the stored config per key, the same rule every route applies. The
+ * parsers read a `Record<string, unknown>` body (or a URL query) and build
+ * the request with only the keys that are present, so
+ * exactOptionalPropertyTypes never sees a `key: undefined` write.
+ * @module dsh-plugin-local-infer/ui/request
+ */
+import type { Config } from 'dsh-plugin-local-infer/core';
+import type { StoredPlatformConfig } from './config.ts';
+/**
+ * DepsRequest is the query the card sends for the deps panel: the engine and
+ * the config the build mode reads from. Absent values fall back to the stored
+ * config, the same rule the summary route applies.
+ */
+export interface DepsRequest {
+    engine?: string;
+    config?: Config;
+}
+/**
+ * DownloadRequest is the query the card sends for the download route: the
+ * engine, model, and directory the hf CLI download targets. Absent values
+ * fall back to the stored config, the same rule the summary route applies.
+ */
+export interface DownloadRequest {
+    engine?: string;
+    model?: string;
+    directory?: string;
+}
+/**
+ * ChatTemplateDownloadRequest is the query the card sends for the chat-template
+ * download route: the engine, the template repo reference, and the directory
+ * the hf CLI targets. Absent values fall back to the stored config, the same
+ * rule the summary route applies.
+ */
+export interface ChatTemplateDownloadRequest {
+    engine?: string;
+    template?: string;
+    directory?: string;
+}
+/**
+ * LaunchRequest is the query the card sends for the launch and stop routes: the
+ * engine and the config the plan renders from. `platform` carries the card's
+ * unsaved Engine Directory / Engine Fork edits for the engine, so a launch uses
+ * them without a prior save. `providerId` names the saved provider entry the
+ * launch drives, so the route persists the launch record (or clears it on a
+ * stop) on that entry. `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 values fall back to the stored config,
+ * the same rule the summary route applies.
+ */
+export interface LaunchRequest {
+    engine?: string;
+    config?: Config;
+    platform?: StoredPlatformConfig;
+    providerId?: string;
+    autoRebuild?: boolean;
+}
+/**
+ * GetRequest is the query the card sends for the Get route: the engine and
+ * the config the dep plan and the build mode read from, and the platform
+ * override (the card's unsaved Engine Directory / Engine Fork edits), the
+ * same rule the launch request applies. Absent values fall back to the
+ * stored config.
+ */
+export interface GetRequest {
+    engine?: string;
+    config?: Config;
+    platform?: StoredPlatformConfig;
+}
+/**
+ * RegisterRequest is the query the card sends for the register and
+ * unregister routes: the engine and the config the plan renders from, and
+ * agentDefault, which points the agent default model at the registered
+ * engine. Absent values fall back to the stored config, the same rule the
+ * summary route applies.
+ */
+export interface RegisterRequest {
+    engine?: string;
+    config?: Config;
+    agentDefault?: boolean;
+}
+/**
+ * depsRequestFromUrl parses the engine and config query params the GET routes
+ * (summary, deps) read. An absent engine falls back to the stored engine, and
+ * a config that cannot be parsed falls back to the stored config, the same
+ * rule the POST routes apply to a broken body key.
+ */
+export declare function depsRequestFromUrl(url: URL): DepsRequest;
+/**
+ * launchRequestFromBody parses the launch and stop POST body: the engine,
+ * config, and platform override the plan renders from, falling back to the
+ * stored config per key. The stop route ignores the platform key.
+ * `providerId` names the saved provider entry the launch record (or its
+ * stop's clear) targets, and `autoRebuild` carries the card's Auto Rebuild
+ * checkbox.
+ */
+export declare function launchRequestFromBody(body: Record<string, unknown>): LaunchRequest;
+/**
+ * registerRequestFromBody parses the register and unregister POST body: the
+ * engine and config the plan renders from, plus agentDefault for the register
+ * route, falling back to the stored config per key.
+ */
+export declare function registerRequestFromBody(body: Record<string, unknown>): RegisterRequest;
+//# sourceMappingURL=request.d.ts.map

package/packages/ui/lib/request.js

@@ -0,0 +1,80 @@
+/**
+ * The request types the card's routes parse and the parsers that build them.
+ * Every request carries only the keys the card sent: absent values fall back
+ * to the stored config per key, the same rule every route applies. The
+ * parsers read a `Record<string, unknown>` body (or a URL query) and build
+ * the request with only the keys that are present, so
+ * exactOptionalPropertyTypes never sees a `key: undefined` write.
+ * @module dsh-plugin-local-infer/ui/request
+ */
+import { parseStoredPlatformConfig } from "./config.js";
+/**
+ * depsRequestFromUrl parses the engine and config query params the GET routes
+ * (summary, deps) read. An absent engine falls back to the stored engine, and
+ * a config that cannot be parsed falls back to the stored config, the same
+ * rule the POST routes apply to a broken body key.
+ */
+export function depsRequestFromUrl(url) {
+    const request = {};
+    const engineParam = url.searchParams.get('engine');
+    if (engineParam !== null) {
+        request.engine = engineParam;
+    }
+    const configParam = url.searchParams.get('config');
+    if (configParam !== null) {
+        try {
+            request.config = JSON.parse(configParam);
+        }
+        catch {
+            // A config that cannot parse reads as absent, so the stored config wins.
+        }
+    }
+    return request;
+}
+/**
+ * launchRequestFromBody parses the launch and stop POST body: the engine,
+ * config, and platform override the plan renders from, falling back to the
+ * stored config per key. The stop route ignores the platform key.
+ * `providerId` names the saved provider entry the launch record (or its
+ * stop's clear) targets, and `autoRebuild` carries the card's Auto Rebuild
+ * checkbox.
+ */
+export function launchRequestFromBody(body) {
+    const request = {};
+    if (typeof body.engine === 'string') {
+        request.engine = body.engine;
+    }
+    if (body.config && typeof body.config === 'object') {
+        request.config = body.config;
+    }
+    const platform = parseStoredPlatformConfig(body.platform);
+    if (platform !== undefined) {
+        request.platform = platform;
+    }
+    if (typeof body.providerId === 'string' && body.providerId.trim() !== '') {
+        request.providerId = body.providerId;
+    }
+    if (typeof body.autoRebuild === 'boolean') {
+        request.autoRebuild = body.autoRebuild;
+    }
+    return request;
+}
+/**
+ * registerRequestFromBody parses the register and unregister POST body: the
+ * engine and config the plan renders from, plus agentDefault for the register
+ * route, falling back to the stored config per key.
+ */
+export function registerRequestFromBody(body) {
+    const request = {};
+    if (typeof body.engine === 'string') {
+        request.engine = body.engine;
+    }
+    if (body.config && typeof body.config === 'object') {
+        request.config = body.config;
+    }
+    if (typeof body.agentDefault === 'boolean') {
+        request.agentDefault = body.agentDefault;
+    }
+    return request;
+}
+//# sourceMappingURL=request.js.map