dsh-plugin-local-infer 0.1.2 → 0.1.4

package/packages/ui/lib/ops/get-steps.d.ts

@@ -0,0 +1,98 @@
+/**
+ * The shared Get-steps routine both getEngine and launchEngine route through:
+ * it runs, in order, (1) the engine's system-dependency install for the host
+ * OS (gated by the Play/Run trust gate), (2) the git clone of the engine repo
+ * (or the fork) plus the fetch/rebase of a clean checkout, (3) the source
+ * build step (the compose engines carry no local build steps), (4) the hf
+ * download of the selected model when it is not already present, and (5) the
+ * hf download of any selected chat template when it is not already present.
+ * Every step streams through the log sink as it lands, and an already-
+ * satisfied step is skipped and logged as such, so a Launch that runs the
+ * routine before the deploy is idempotent. With an `onStep` reporter (a
+ * Launch's progress sink; a standalone Get passes none) each step announces
+ * its launch phase only when its work actually starts, so the card's button
+ * reads the phase that is running. A Launch can set
+ * `continueOnSyncFailure` on the request: when the git sync (rebase) of an
+ * existing checkout fails, the run keeps going with the checkout's current
+ * version and reports `syncFailed` on the result, so a broken rebase never
+ * halts the launch. A standalone Get omits the flag and keeps stopping on a
+ * sync failure.
+ * @module dsh-plugin-local-infer/ui/ops/get-steps
+ */
+import type { Config, LaunchProgress, LifecycleHost } from 'dsh-plugin-local-infer/core';
+import type { LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { StoredPlatformConfig } from '../config.ts';
+/**
+ * GetStepsRequest names the run: the engine, the config the dep plan, build
+ * mode, model, and chat template read from, the platform entry the checkout
+ * directory and fork resolve against, the Play/Run trust gate that decides
+ * whether the dependency install runs, and the lifecycle host the git and
+ * build steps run through. `autoRebuild` false (the card's Auto Rebuild
+ * checkbox off) skips the sync and build steps, so a launch reads the
+ * checkout as-is, the same rule the adapter's deploy step applies. `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 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`.
+ * `onChunk` is the hf download's raw stderr progress sink: the download
+ * runner hands each streamed stdout and stderr chunk to it as it lands,
+ * separate from the log text sink the step lines stream through, so the
+ * caller parses the tqdm lines into progress events. `onStep` is the launch
+ * phase reporter (the card's button reader): a step announces its phase only
+ * when its work actually starts (the dep install, the sync/build, a model or
+ * template download), so a satisfied-and-skipped step announces nothing. A
+ * standalone Get passes none (its control keeps its throbber); a Launch
+ * threads its route progress sink here. `continueOnSyncFailure`
+ * (a Launch-only flag) keeps the run going when the git sync of an existing
+ * checkout fails: the run reports `syncFailed` on the result and the launch
+ * continues with the checkout's current version, so a broken rebase never
+ * halts it. A standalone Get omits it and stops on a sync failure.
+ */
+export interface GetStepsRequest {
+    engineId: string;
+    config: Config;
+    platform?: StoredPlatformConfig;
+    allowRunDeps: boolean;
+    autoRebuild?: boolean;
+    continueOnSyncFailure?: boolean;
+    host: LifecycleHost;
+    signal?: AbortSignal;
+    onChunk?: (chunk: string) => void;
+    onStep?: LaunchProgress;
+}
+/**
+ * GetStepsResult reports the run: whether every step passed, a detail the
+ * Logs section shows when one did not, and the captured log text (every step
+ * line, in order) the caller persists or streams to the card. `syncFailed`
+ * marks a run that kept going after a non-fatal git sync failure (the
+ * `continueOnSyncFailure` override): `ok` stays true and the caller threads
+ * the flag into the launch so the deploy skips its own git sync and launches
+ * the checkout's current version.
+ */
+export interface GetStepsResult {
+    ok: boolean;
+    logs: string;
+    detail?: string;
+    syncFailed?: boolean;
+}
+/**
+ * resolveEngineDirectory picks the checkout the Get step syncs: the Engine
+ * Directory override when it names a path, else the engine's default
+ * checkout home `~/.cache/dsh/infer/{engineId}` (one checkout per engine,
+ * never a subfolder of a model directory), so a Get with no override still
+ * has a real place to live.
+ */
+export declare function resolveEngineDirectory(engineId: string, platform: StoredPlatformConfig | undefined): string;
+/**
+ * runGetSteps is the shared Get-steps routine. It runs the five steps in
+ * order, streaming each through log and collecting the same text as the
+ * result's logs, so a caller can persist the run (a Get) or thread it into
+ * the launch's persisted logs (a Launch) without re-running the steps. A
+ * step that is already satisfied is skipped and logged as such; a failing
+ * step stops the run and names the broken step in the detail. A step that
+ * fails non-fatally (the git sync under the `continueOnSyncFailure`
+ * override) keeps the run going and threads `syncFailed` into the result, so
+ * the launch continues with the checkout's current version.
+ */
+export declare function runGetSteps(localInfer: LocalInferService, request: GetStepsRequest, log: (chunk: string) => void): Promise<GetStepsResult>;
+//# sourceMappingURL=get-steps.d.ts.map

package/packages/ui/lib/ops/get-steps.js

@@ -0,0 +1,359 @@
+/**
+ * The shared Get-steps routine both getEngine and launchEngine route through:
+ * it runs, in order, (1) the engine's system-dependency install for the host
+ * OS (gated by the Play/Run trust gate), (2) the git clone of the engine repo
+ * (or the fork) plus the fetch/rebase of a clean checkout, (3) the source
+ * build step (the compose engines carry no local build steps), (4) the hf
+ * download of the selected model when it is not already present, and (5) the
+ * hf download of any selected chat template when it is not already present.
+ * Every step streams through the log sink as it lands, and an already-
+ * satisfied step is skipped and logged as such, so a Launch that runs the
+ * routine before the deploy is idempotent. With an `onStep` reporter (a
+ * Launch's progress sink; a standalone Get passes none) each step announces
+ * its launch phase only when its work actually starts, so the card's button
+ * reads the phase that is running. A Launch can set
+ * `continueOnSyncFailure` on the request: when the git sync (rebase) of an
+ * existing checkout fails, the run keeps going with the checkout's current
+ * version and reports `syncFailed` on the result, so a broken rebase never
+ * halts the launch. A standalone Get omits the flag and keeps stopping on a
+ * sync failure.
+ * @module dsh-plugin-local-infer/ui/ops/get-steps
+ */
+import { autoRebuildEnabled, chatTemplatePresent, checkDeps, commandLogLine, dshEngineCacheDirectory, modelArtifactPresent, resolveModelDirectory, } from '../../../core/lib/index.js';
+import { buildEngineRepo, defaultModelFor, ENGINES, infernixGetDownloads, syncEngineRepo, } from '../../../providers/lib/index.js';
+import { isHfRepoReference } from "../viewmodels/summaryHelpers.js";
+import { resolveBuildMode } from "../viewmodels/deps.js";
+/**
+ * resolveEngineDirectory picks the checkout the Get step syncs: the Engine
+ * Directory override when it names a path, else the engine's default
+ * checkout home `~/.cache/dsh/infer/{engineId}` (one checkout per engine,
+ * never a subfolder of a model directory), so a Get with no override still
+ * has a real place to live.
+ */
+export function resolveEngineDirectory(engineId, platform) {
+    const override = platform?.engineDirectory;
+    if (override !== undefined && override.trim() !== '') {
+        return override;
+    }
+    return dshEngineCacheDirectory(engineId);
+}
+/**
+ * The marker a Get step reports when it fails non-fatally: the git sync of
+ * an existing checkout failed while the `continueOnSyncFailure` override is
+ * on, so the runner keeps going (skipping the build) and threads
+ * `syncFailed` into the result while the launch continues.
+ */
+const SYNC_FAILED = { kind: 'syncFailed' };
+/**
+ * downloadOptions builds the exactOptionalPropertyTypes-safe download options
+ * a Get step's hf download runs with: the hub-cache layout flag, the run's
+ * cancel signal, the onChunk progress sink, and the run's log sink (emit) so
+ * the service writes the `$ <hf command>` line into the same log text the step
+ * streams, ahead of the download's output. Each field is present only when the
+ * run carries it, so an absent field never writes `undefined`. The model and
+ * chat-template steps share it, so the option group (the directory layout, the
+ * cancel, the progress sink, the log sink) is built in one place.
+ */
+function downloadOptions(ctx) {
+    return {
+        useHubCache: ctx.target.useHubCache,
+        onLog: ctx.emit,
+        ...(ctx.request.signal !== undefined ? { signal: ctx.request.signal } : {}),
+        ...(ctx.onChunk !== undefined ? { onChunk: ctx.onChunk } : {}),
+    };
+}
+/**
+ * runDepsStep is the Get step's system-dependency install: it runs the
+ * install while the Play/Run trust gate is on, and re-checks the deps with
+ * a copy/paste note when the gate is off, so a missing dependency aborts the
+ * run instead of a broken build.
+ */
+async function runDepsStep(ctx) {
+    const { localInfer, request, engine, hardware, emit } = ctx;
+    const buildMode = resolveBuildMode(engine, request.config);
+    emit(`system dependencies (${buildMode})\n`);
+    if (request.allowRunDeps === true) {
+        // The prereqs phase runs only here: with the gate on the install actually
+        // runs, so the step announces it as it starts (the gate-off re-check
+        // below is not a prereqs phase and announces nothing).
+        request.onStep?.('prereqs');
+        // The install run's log sink is this step's emit, so the service writes
+        // each dependency install command's `$ <command>` line into the same run
+        // text (ahead of the per-dep results below) before the guarded runner
+        // spawns the child.
+        const install = await localInfer.runInstall(request.engineId, buildMode, hardware, {
+            onLog: emit,
+        });
+        for (const entry of install.results) {
+            emit(`  ${entry.id}: ${entry.status}${entry.detail !== undefined ? ` (${entry.detail})` : ''}\n`);
+        }
+        if (!install.ok) {
+            emit('!! a system dependency install failed; copy the install string from the panel\n');
+            return { ok: false, detail: 'a system dependency install failed' };
+        }
+        return null;
+    }
+    const deps = await localInfer.deps(request.engineId, buildMode, hardware);
+    const checks = await checkDeps(deps, hardware);
+    let missing = false;
+    for (const check of checks) {
+        emit(`  ${check.dep.id}: ${check.status}\n`);
+        if (check.status !== 'satisfied')
+            missing = true;
+    }
+    if (missing) {
+        emit('!! a system dependency is missing and one-click install is off; copy the install string from the panel\n');
+        return { ok: false, detail: 'a system dependency is missing' };
+    }
+    return null;
+}
+/**
+ * runSyncBuildStep is the Get step's git clone (or fork) of the engine repo,
+ * the fetch and rebase of a clean checkout, and the source build step (the
+ * compose engines carry no local build steps and pass through). A checkout
+ * with local changes aborts, so the user's work is never rebased away. The
+ * Auto Rebuild checkbox off skips both, so a launch reads the checkout as-is.
+ * Under the `continueOnSyncFailure` override, a failed sync of an existing
+ * checkout reports the SYNC_FAILED marker (the run keeps going with the
+ * checkout's current version and the build is skipped); a failed clone of a
+ * missing checkout stays fatal, since there is no current version to launch.
+ */
+async function runSyncBuildStep(ctx) {
+    const { request, directory, emit } = ctx;
+    if (!autoRebuildEnabled(request.autoRebuild)) {
+        emit('engine sync and build: auto rebuild off, skipped\n');
+        return null;
+    }
+    // The sync and build actually run (the Auto Rebuild checkbox is not off),
+    // so the step announces its build phase as it starts; a skipped step
+    // announces nothing.
+    request.onStep?.('build');
+    // The distinct clone and build headers let the Logs-header step chips track
+    // the two sub-steps separately: the clone chip runs until the build header
+    // lands, and the build chip runs until the model header lands.
+    emit(`engine clone: ${request.engineId}\n`);
+    const fork = request.platform?.engineFork;
+    const sync = await syncEngineRepo(request.host, {
+        engineId: request.engineId,
+        directory,
+        ...(fork !== undefined && fork.trim() !== '' ? { fork } : {}),
+    }, emit);
+    if (!sync.ok) {
+        // A dirty checkout already alerted in the sync step; any other failure
+        // names its step here.
+        if (sync.aborted !== true && sync.detail !== undefined) {
+            emit(`!! ${sync.detail}\n`);
+        }
+        // The `continueOnSyncFailure` override (a Launch-only flag): when the git
+        // sync of an existing checkout fails, the run keeps going with the
+        // checkout's current version (the build is skipped, since the rebase
+        // failed and the checkout stays where it is) and reports the failure
+        // non-fatally, so a broken rebase never halts the launch. The sync result
+        // names the path it took: a fresh clone (cloned) means no prior checkout
+        // to launch, so a clone failure stays fatal; a rebase, fetch, or dirty
+        // checkout of an existing checkout (no clone) is non-fatal under the
+        // override. Reading the flag keeps the checkout-presence decision in the
+        // one place that probes it (the git rev-parse in the sync step).
+        if (request.continueOnSyncFailure === true && sync.cloned !== true) {
+            emit('!! engine sync failed; continuing with the current version\n');
+            return SYNC_FAILED;
+        }
+        return {
+            ok: false,
+            ...(sync.detail !== undefined ? { detail: sync.detail } : {}),
+        };
+    }
+    // The user's local build command (the card's Build commands field)
+    // overrides the engine's default build steps; absent runs the engine's
+    // acquisition steps. The host OS picks the engine's OS profile (the
+    // Windows vcpkg route and its pwsh.exe shell on a Windows host, the
+    // cmake route elsewhere).
+    emit(`engine build: ${request.engineId}\n`);
+    const build = await buildEngineRepo(request.host, request.engineId, directory, emit, request.platform?.buildCommands, ctx.hardware.os);
+    if (!build.ok) {
+        if (build.detail !== undefined) {
+            emit(`!! ${build.detail}\n`);
+        }
+        return {
+            ok: false,
+            ...(build.detail !== undefined ? { detail: build.detail } : {}),
+        };
+    }
+    return null;
+}
+/**
+ * runModelDownloadStep is the Get step's hf download of the selected model,
+ * skipped when the artifact is already present in the model directory (the
+ * hub cache under the cache layout; the single presence check the card's
+ * Model dropdown and the download route share), plus the Infernix extras a
+ * Get leaves ready to launch (the selected DFlash2 drafter and the PLE n-gram
+ * volume, pulled through the hf CLI into the model directory). A download
+ * failure aborts the run, so a launch never reads a missing model.
+ */
+async function runModelDownloadStep(ctx) {
+    const { localInfer, request, target, emit } = ctx;
+    const modelId = typeof request.config.model === 'string' ? request.config.model : undefined;
+    if (modelId !== undefined) {
+        const entry = ctx.modelEntry;
+        if (entry === undefined) {
+            emit(`model download: ${modelId} has no registered default, skipped\n`);
+        }
+        else {
+            // The shared presence check resolves the deterministic hub-cache
+            // snapshot under the cache layout and joins the artifact onto the
+            // override under the flat layout (the target's base).
+            if (modelArtifactPresent(entry, target.baseDir, target.useHubCache)) {
+                emit(`model download: ${modelId} is already present, skipped\n`);
+            }
+            else {
+                // The download actually runs, so the step announces its download
+                // phase as it starts; an already-present artifact announces nothing.
+                request.onStep?.('download');
+                // The `$ <hf download ...>` line is written by the service's download
+                // exec site (through downloadOptions' onLog), so the command logs
+                // exactly once per run, from wherever the child actually spawns.
+                const download = await localInfer.downloadModel(entry, target.directory, downloadOptions(ctx));
+                if (!download.ok) {
+                    emit(`!! ${download.detail ?? 'model download failed'}\n`);
+                    return { ok: false, detail: download.detail ?? 'a model download failed' };
+                }
+            }
+        }
+    }
+    else {
+        emit('model download: no model selected, skipped\n');
+    }
+    if (request.engineId === 'infernix') {
+        const extras = infernixGetDownloads(request.config, target.directory, target.useHubCache);
+        if (extras.length > 0) {
+            // The extras actually download (even when the selected artifact was
+            // already present), so the step announces its download phase once here.
+            request.onStep?.('download');
+        }
+        for (const command of extras) {
+            emit(commandLogLine(command));
+            // The Infernix extra downloads stream through the host, so their tqdm
+            // lines reach the log sink and the onChunk progress sink together, the
+            // way the model and template downloads do. A caller that does not
+            // stream progress (onChunk absent) still lands the chunk in the log
+            // sink only.
+            const stream = request.host.runStream;
+            const outcome = stream !== undefined
+                ? await stream.call(request.host, command, (chunk) => {
+                    emit(chunk);
+                    ctx.onChunk?.(chunk);
+                }, {
+                    ...(request.signal !== undefined ? { signal: request.signal } : {}),
+                })
+                : await request.host.run(command);
+            if (!outcome.ok) {
+                emit(`!! ${command} failed: ${outcome.detail ?? 'unknown'}\n`);
+                return { ok: false, detail: 'a model artifact download failed' };
+            }
+            // The plain-run fallback cannot stream, so the outcome's capped success
+            // output tail lands after the `$ <command>` line: the exec rule's
+            // append-results half, the way the streaming path already does.
+            if (stream === undefined &&
+                outcome.stdout !== undefined &&
+                outcome.stdout !== '') {
+                emit(outcome.stdout.endsWith('\n') ? outcome.stdout : `${outcome.stdout}\n`);
+            }
+        }
+    }
+    return null;
+}
+/**
+ * runChatTemplateStep is the Get step's hf download of the selected chat
+ * template (an HF repo reference the form's combo control offers), skipped
+ * when the template file is already present in the model directory.
+ */
+async function runChatTemplateStep(ctx) {
+    const { localInfer, request, target, emit } = ctx;
+    const template = typeof request.config.chatTemplate === 'string' ? request.config.chatTemplate : '';
+    if (template !== '' && isHfRepoReference(template)) {
+        // Same shared presence check as the summary's template row: the cache
+        // layout resolves the deterministic snapshot, the flat layout joins onto
+        // the override.
+        if (chatTemplatePresent(template, target.baseDir, target.useHubCache)) {
+            emit(`chat template: ${template} is already present, skipped\n`);
+        }
+        else {
+            // The template download actually runs, so the step announces its
+            // download phase as it starts.
+            request.onStep?.('download');
+            // The `$ <hf chat-template ...>` line is written by the service's
+            // download exec site (through downloadOptions' onLog), logging once.
+            const download = await localInfer.downloadChatTemplate(template, target.directory, downloadOptions(ctx));
+            if (!download.ok) {
+                emit(`!! ${download.detail ?? 'chat template download failed'}\n`);
+                return { ok: false, detail: download.detail ?? 'a chat template download failed' };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * runGetSteps is the shared Get-steps routine. It runs the five steps in
+ * order, streaming each through log and collecting the same text as the
+ * result's logs, so a caller can persist the run (a Get) or thread it into
+ * the launch's persisted logs (a Launch) without re-running the steps. A
+ * step that is already satisfied is skipped and logged as such; a failing
+ * step stops the run and names the broken step in the detail. A step that
+ * fails non-fatally (the git sync under the `continueOnSyncFailure`
+ * override) keeps the run going and threads `syncFailed` into the result, so
+ * the launch continues with the checkout's current version.
+ */
+export async function runGetSteps(localInfer, request, log) {
+    const chunks = [];
+    const emit = (chunk) => {
+        chunks.push(chunk);
+        log(chunk);
+    };
+    // ENGINES is a known non-empty constant, so the fallback is always defined.
+    const engine = ENGINES.find((entry) => entry.id === request.engineId) ?? ENGINES[0];
+    // The shared resolution owns the layout rule: the hub-cache layout (no
+    // --local-dir, the models--{ns}--{name} dirs) applies only when the raw
+    // config names no model directory; a user override keeps the flat
+    // --local-dir target. The target's base is what the presence checks join
+    // onto, and its directory names the model directory the steps run: the
+    // override, the hub-cache snapshot holding a cached artifact (the hf
+    // download result), or the hub cache root when nothing is cached yet. The
+    // hub cache root comes from the service seam (created when absent), the
+    // same source the summary and the download routes read.
+    const selectedModelId = typeof request.config.model === 'string' ? request.config.model : undefined;
+    const modelEntry = selectedModelId === undefined ? undefined : defaultModelFor(request.engineId, selectedModelId);
+    const ctx = {
+        localInfer,
+        request,
+        engine,
+        directory: resolveEngineDirectory(request.engineId, request.platform),
+        target: resolveModelDirectory(request.config.modelDirectory, modelEntry, localInfer.defaultModelDirectory()),
+        ...(modelEntry !== undefined ? { modelEntry } : {}),
+        hardware: await localInfer.detectHardware(),
+        emit,
+        ...(request.onChunk !== undefined ? { onChunk: request.onChunk } : {}),
+    };
+    ctx.emit(`get ${request.engineId} in ${ctx.directory}\n`);
+    // A non-fatal sync failure (the `continueOnSyncFailure` override) keeps the
+    // run going through the remaining steps; the flag threads into the result
+    // so the launch skips the deploy's own git sync and launches the checkout's
+    // current version.
+    let syncFailed = false;
+    for (const step of [runDepsStep, runSyncBuildStep, runModelDownloadStep, runChatTemplateStep]) {
+        const failure = await step(ctx);
+        if (failure !== null) {
+            if ('kind' in failure) {
+                syncFailed = true;
+                continue;
+            }
+            return { ...failure, logs: chunks.join('') };
+        }
+    }
+    ctx.emit('get complete\n');
+    return {
+        ok: true,
+        logs: chunks.join(''),
+        ...(syncFailed ? { syncFailed: true } : {}),
+    };
+}
+//# sourceMappingURL=get-steps.js.map

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

@@ -0,0 +1,42 @@
+/**
+ * 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 through resolveDownloadTarget
+ * (the request, the stored config, and the hub cache root in that order,
+ * through the shared override rule), so the hub-cache layout rule has one
+ * home across the download routes and the card.
+ * @module dsh-plugin-local-infer/ui/ops/hf
+ */
+import type { DownloadResult, LocalInferService } from 'dsh-plugin-local-infer/service';
+import type { ChatTemplateDownloadRequest, DownloadRequest } from '../request.ts';
+/**
+ * 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 through
+ * resolveDownloadTarget, and runs the download through the service. The run
+ * brackets one live hub run under the runLogKey rule keyed on the entry's
+ * engine and model (a draft falls back to the engine id): the seed is the
+ * "Downloading..." separator, the hf CLI's streamed chunks append as they
+ * land, and the settled completion or failure line reaches the hub and the
+ * persisted run from one text before the run ends. The optional signal is
+ * the card's cancel (the download route's response-close abort, the Get and
+ * launch routes' rule): an abort interrupts the in-flight hf child (SIGINT,
+ * then SIGTERM) and the run carries the shared "Canceled" line, live and
+ * persisted.
+ */
+export declare function downloadFor(localInfer: LocalInferService, request: DownloadRequest, signal?: AbortSignal): Promise<DownloadResult>;
+/**
+ * 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 through resolveDownloadTarget, and
+ * runs the download through the service. The run brackets one live hub run
+ * under the "Downloading..." seed and the runLogKey rule (the stored entry
+ * matching the engine and model, else the engine id): the hf CLI's streamed
+ * chunks append as they land, and the run ends at settle. The optional
+ * signal is the card's cancel (the chat-template route's response-close
+ * abort, the Get and launch routes' rule): an abort interrupts the in-flight
+ * hf child and the live run carries the shared "Canceled" line.
+ */
+export declare function chatTemplateDownloadFor(localInfer: LocalInferService, request: ChatTemplateDownloadRequest, signal?: AbortSignal): Promise<DownloadResult>;
+//# sourceMappingURL=hf.d.ts.map

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

@@ -0,0 +1,150 @@
+/**
+ * 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 through resolveDownloadTarget
+ * (the request, the stored config, and the hub cache root in that order,
+ * through the shared override rule), so the hub-cache layout rule has one
+ * home across the download routes and the card.
+ * @module dsh-plugin-local-infer/ui/ops/hf
+ */
+import { isModelDirectoryOverridden, modelDownloadTarget } from '../../../core/lib/index.js';
+import { runLogKey } from '../../../service/lib/index.js';
+import { defaultModelFor } from '../../../providers/lib/index.js';
+import { readConfig } from "../config.js";
+import { CANCELED_LINE, DOWNLOAD_RUN_SEED, persistProcessLog } from "./logs.js";
+import { RouteError } from "../route.js";
+import { isHfRepoReference } from "../viewmodels/summaryHelpers.js";
+/**
+ * resolveDownloadTarget resolves the directory a download route targets: the
+ * request's directory, the stored config's model directory, and the hub
+ * cache root, in that order. The first named directory wins (the shared
+ * override predicate), then the shared modelDownloadTarget rule decides the
+ * layout: a named directory keeps the flat --local-dir target; only when
+ * neither names one does the hub-cache layout apply, based on the hub cache
+ * root (the service seam: the hf CLI's own download home, which resolves its
+ * own snapshot destination and creates the directory when absent), so a
+ * download never materializes a snapshot-directory or hub-root override into
+ * the config.
+ */
+function resolveDownloadTarget(localInfer, requestDirectory, stored) {
+    const named = isModelDirectoryOverridden(requestDirectory)
+        ? requestDirectory
+        : stored.config.modelDirectory;
+    return modelDownloadTarget(named, localInfer.defaultModelDirectory());
+}
+/**
+ * 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 through
+ * resolveDownloadTarget, and runs the download through the service. The run
+ * brackets one live hub run under the runLogKey rule keyed on the entry's
+ * engine and model (a draft falls back to the engine id): the seed is the
+ * "Downloading..." separator, the hf CLI's streamed chunks append as they
+ * land, and the settled completion or failure line reaches the hub and the
+ * persisted run from one text before the run ends. The optional signal is
+ * the card's cancel (the download route's response-close abort, the Get and
+ * launch routes' rule): an abort interrupts the in-flight hf child (SIGINT,
+ * then SIGTERM) and the run carries the shared "Canceled" line, live and
+ * persisted.
+ */
+export async function downloadFor(localInfer, request, signal) {
+    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 { baseDir, useHubCache } = resolveDownloadTarget(localInfer, request.directory, stored);
+    // The key rule prices the model this download fetches, so the run lands on
+    // the stored entry for that engine and model, not the draft's.
+    const runKey = runLogKey(stored.providers, engineId, undefined, {
+        ...stored.config,
+        ...(modelId === '' ? {} : { model: modelId }),
+    });
+    localInfer.beginRun(runKey, DOWNLOAD_RUN_SEED);
+    // The service writes the rendered hf command's `$ <command>` line through
+    // onLog before it spawns the child: it streams into the live hub right away
+    // and rides the persisted section below, so the command line reads exactly
+    // once per run in both readers, ahead of the CLI's output.
+    let commandLine = '';
+    try {
+        const result = await localInfer.downloadModel(entry, baseDir, {
+            useHubCache,
+            ...(signal !== undefined ? { signal } : {}),
+            onChunk: (chunk) => {
+                localInfer.appendRunLog(runKey, chunk);
+            },
+            onLog: (line) => {
+                commandLine += line;
+                localInfer.appendRunLog(runKey, line);
+            },
+        });
+        // The settle line reads the same in the live run and the persisted one:
+        // the "Downloading..." separator leads the stored run so the Logs
+        // section and the log file read the download as a fresh process section.
+        // A cancel appends the shared "Canceled" line, the Get and launch
+        // routes' mark, so the run reads as canceled wherever it is read.
+        const line = result.ok
+            ? 'download complete\n'
+            : `!! download failed${result.detail !== undefined ? `: ${result.detail}` : ''}\n`;
+        const settled = signal?.aborted === true ? `${line}${CANCELED_LINE}` : line;
+        localInfer.appendRunLog(runKey, settled);
+        persistProcessLog(`${DOWNLOAD_RUN_SEED}${commandLine}${settled}`);
+        return result;
+    }
+    finally {
+        localInfer.endRun(runKey);
+    }
+}
+/**
+ * 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 through resolveDownloadTarget, and
+ * runs the download through the service. The run brackets one live hub run
+ * under the "Downloading..." seed and the runLogKey rule (the stored entry
+ * matching the engine and model, else the engine id): the hf CLI's streamed
+ * chunks append as they land, and the run ends at settle. The optional
+ * signal is the card's cancel (the chat-template route's response-close
+ * abort, the Get and launch routes' rule): an abort interrupts the in-flight
+ * hf child and the live run carries the shared "Canceled" line.
+ */
+export async function chatTemplateDownloadFor(localInfer, request, signal) {
+    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 { baseDir, useHubCache } = resolveDownloadTarget(localInfer, request.directory, stored);
+    const runKey = runLogKey(stored.providers, request.engine ?? stored.engine, undefined, stored.config);
+    localInfer.beginRun(runKey, DOWNLOAD_RUN_SEED);
+    try {
+        const result = await localInfer.downloadChatTemplate(template, baseDir, {
+            useHubCache,
+            ...(signal !== undefined ? { signal } : {}),
+            onChunk: (chunk) => {
+                localInfer.appendRunLog(runKey, chunk);
+            },
+            // The service writes the rendered chat-template pull's `$ <command>`
+            // line through onLog before it spawns the child, so the live run reads
+            // the command ahead of the CLI's output, exactly once.
+            onLog: (line) => {
+                localInfer.appendRunLog(runKey, line);
+            },
+        });
+        // A cancel marks the live run canceled; the template pull's outcome
+        // rides the card's template cell, not the persisted run, so no persist.
+        if (signal?.aborted === true) {
+            localInfer.appendRunLog(runKey, CANCELED_LINE);
+        }
+        return result;
+    }
+    finally {
+        localInfer.endRun(runKey);
+    }
+}
+//# sourceMappingURL=hf.js.map