dsh-plugin-local-infer 0.1.3 → 0.1.4

package/packages/core/lib/hf-cache.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Hf cache directory resolution: the default Hugging Face cache locations the
+ * plugin's model and dataset downloads target. The precedence mirrors
+ * huggingface_hub, so a download through the plugin lands where the hf CLI
+ * and the Python libraries look: the per-store override wins, then the
+ * HF_HOME global, then the platform default under the user home.
+ * @module dsh-plugin-local-infer/core/hf-cache
+ */
+import type { ModelDownloadSource } from './models.ts';
+/**
+ * hfHubCacheDirectory resolves the Hugging Face hub cache directory (models,
+ * tokenizers, and hub spaces): HF_HUB_CACHE when set, else $HF_HOME/hub when
+ * HF_HOME is set, else ~/.cache/huggingface/hub.
+ */
+export declare function hfHubCacheDirectory(): string;
+/**
+ * ModelDownloadTarget is the resolved download target for one model
+ * directory: the base directory the hf CLI writes into and whether the
+ * hub-cache layout (no --local-dir, the models--{ns}--{name} directories)
+ * applies. The rule is the single source the adapters' deploy steps and the
+ * download routes share: it reads the raw model-directory field through the
+ * shared override predicate (isModelDirectoryOverridden), so a named
+ * directory keeps the flat --local-dir target and an absent or blank one
+ * downloads into the hub cache.
+ */
+export interface ModelDownloadTarget {
+    baseDir: string;
+    useHubCache: boolean;
+}
+/**
+ * modelDownloadTarget resolves the download target for a raw model-directory
+ * field: a named directory is the flat --local-dir base, and an absent or
+ * blank directory is the hub-cache layout (the hf CLI writes its
+ * models--{ns}--{name} directories into the hub cache root). `hubCache` is
+ * the hub cache root to fall back onto; the default reads the core
+ * resolution, and a caller that owns the value (the service seam, which also
+ * creates the directory when absent) passes it.
+ */
+export declare function modelDownloadTarget(modelDirectory: unknown, hubCache?: string): ModelDownloadTarget;
+/**
+ * ModelDirectoryResolution is the full model-directory read for one raw
+ * config field: the ModelDownloadTarget (the download and presence-join base
+ * plus the layout flag) extended with the concrete `directory` a read shows
+ * and lists. Under the hub-cache layout that directory is the hf download
+ * result: the snapshot holding the selected artifact when it is cached, else
+ * the hub cache root.
+ */
+export interface ModelDirectoryResolution extends ModelDownloadTarget {
+    directory: string;
+}
+/**
+ * resolveModelDirectory resolves the model directory a read names for a
+ * model: the raw field's override when it names a path; else, when the
+ * selected entry resolves and its artifact is already in the hub cache, the
+ * hf download result (the snapshot directory holding it); else the hub cache
+ * root, the base the hf CLI downloads into. The result is derived on every
+ * read and never written back into the config, so a default install never
+ * materializes a fake `modelDirectory` override. `hubCache` is the hub cache
+ * root to resolve over; the service seam names it when it owns the value (it
+ * also creates the directory when absent), and the default reads the core
+ * resolution.
+ */
+export declare function resolveModelDirectory(modelDirectory: unknown, source?: ModelDownloadSource, hubCache?: string): ModelDirectoryResolution;
+/**
+ * hfDatasetsCacheDirectory resolves the Hugging Face datasets cache
+ * directory: HF_DATASETS_CACHE when set, else $HF_HOME/datasets when HF_HOME
+ * is set, else ~/.cache/huggingface/datasets.
+ */
+export declare function hfDatasetsCacheDirectory(): string;
+//# sourceMappingURL=hf-cache.d.ts.map

package/packages/core/lib/hf-cache.js

@@ -0,0 +1,83 @@
+/**
+ * Hf cache directory resolution: the default Hugging Face cache locations the
+ * plugin's model and dataset downloads target. The precedence mirrors
+ * huggingface_hub, so a download through the plugin lands where the hf CLI
+ * and the Python libraries look: the per-store override wins, then the
+ * HF_HOME global, then the platform default under the user home.
+ * @module dsh-plugin-local-infer/core/hf-cache
+ */
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { hfDownloadResultDirectory } from "./infer-cache.js";
+import { isModelDirectoryOverridden, repoIdFromUrl } from "./models.js";
+// The platform default HF home: ~/.cache/huggingface on Linux and macOS,
+// C:\Users\<user>\.cache\huggingface on Windows. homedir() names the right
+// base on every host.
+function defaultHfHome() {
+    return join(homedir(), '.cache', 'huggingface');
+}
+// A set env var that is blank (an empty string or whitespace only) reads as
+// unset, the same rule huggingface_hub applies.
+function envValue(name) {
+    const value = process.env[name];
+    return typeof value === 'string' && value.trim() !== '' ? value : undefined;
+}
+/**
+ * hfHubCacheDirectory resolves the Hugging Face hub cache directory (models,
+ * tokenizers, and hub spaces): HF_HUB_CACHE when set, else $HF_HOME/hub when
+ * HF_HOME is set, else ~/.cache/huggingface/hub.
+ */
+export function hfHubCacheDirectory() {
+    const hub = envValue('HF_HUB_CACHE');
+    if (hub !== undefined)
+        return hub;
+    const home = envValue('HF_HOME');
+    return join(home ?? defaultHfHome(), 'hub');
+}
+/**
+ * modelDownloadTarget resolves the download target for a raw model-directory
+ * field: a named directory is the flat --local-dir base, and an absent or
+ * blank directory is the hub-cache layout (the hf CLI writes its
+ * models--{ns}--{name} directories into the hub cache root). `hubCache` is
+ * the hub cache root to fall back onto; the default reads the core
+ * resolution, and a caller that owns the value (the service seam, which also
+ * creates the directory when absent) passes it.
+ */
+export function modelDownloadTarget(modelDirectory, hubCache = hfHubCacheDirectory()) {
+    const useHubCache = !isModelDirectoryOverridden(modelDirectory);
+    return { baseDir: useHubCache ? hubCache : modelDirectory, useHubCache };
+}
+/**
+ * resolveModelDirectory resolves the model directory a read names for a
+ * model: the raw field's override when it names a path; else, when the
+ * selected entry resolves and its artifact is already in the hub cache, the
+ * hf download result (the snapshot directory holding it); else the hub cache
+ * root, the base the hf CLI downloads into. The result is derived on every
+ * read and never written back into the config, so a default install never
+ * materializes a fake `modelDirectory` override. `hubCache` is the hub cache
+ * root to resolve over; the service seam names it when it owns the value (it
+ * also creates the directory when absent), and the default reads the core
+ * resolution.
+ */
+export function resolveModelDirectory(modelDirectory, source, hubCache = hfHubCacheDirectory()) {
+    const target = modelDownloadTarget(modelDirectory, hubCache);
+    if (!target.useHubCache)
+        return { ...target, directory: target.baseDir };
+    const snapshot = source === undefined
+        ? null
+        : hfDownloadResultDirectory(hubCache, repoIdFromUrl(source.url), source.file ?? '');
+    return { ...target, directory: snapshot ?? hubCache };
+}
+/**
+ * hfDatasetsCacheDirectory resolves the Hugging Face datasets cache
+ * directory: HF_DATASETS_CACHE when set, else $HF_HOME/datasets when HF_HOME
+ * is set, else ~/.cache/huggingface/datasets.
+ */
+export function hfDatasetsCacheDirectory() {
+    const datasets = envValue('HF_DATASETS_CACHE');
+    if (datasets !== undefined)
+        return datasets;
+    const home = envValue('HF_HOME');
+    return join(home ?? defaultHfHome(), 'datasets');
+}
+//# sourceMappingURL=hf-cache.js.map

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

@@ -8,7 +8,7 @@
 export type { Config, CustomArg } from './config.ts';
 export { detectHardware, parseNvidiaSmiGpu, } from './hardware.ts';
 export type { GpuProfile, GpuProbe, HardwareProfile, HardwareProbes, } from './hardware.ts';
-export type { ComboOption, ConstraintResult, EnumOption, ParameterForm, ParameterSpec, } from './parameter.ts';
+export type { ComboOption, ConstraintResult, EnumOption, ParameterDeploy, ParameterForm, ParameterSpec, } from './parameter.ts';
 export { DEFAULT_OS_RESERVE_MIB, estimateVram, KV_PAGE_TOKENS, pageRoundUp, TIGHT_HEADROOM_BYTES, } from './estimator.ts';
 export type { EstimateContext, EstimateOptions, SpeculationTerms, VramBreakdown, VramContribution, VramEstimate, VramModel, VramVerdict, } from './estimator.ts';
 export { GPU_USAGE_BUSY_THRESHOLD, matchLaunchSignature, parseNvidiaSmiGpuUsage, resolveOsReserve, } from './reserve.ts';
@@ -18,19 +18,26 @@ export type { ProviderLaunchRecord, ReLinkInput, ReLinkOutcome, } from './launch
 export type { EngineLaunchSignature, GpuUsageProbe, ProcessLine, ReserveResolution, ReserveSource, } from './reserve.ts';
 export { computeProviderStatuses, isGpuBusy, } from './status.ts';
 export type { ProviderRef, ProviderStatus, ProviderStatusInput, RunningEngineRef, } from './status.ts';
-export { DEFAULT_LOG_PATH_TEMPLATE, LOG_FILE_NAME_TEMPLATE, LOG_TEMPLATE_ENGINE, LOG_TEMPLATE_HOME, LOG_TEMPLATE_MODEL, LOG_TEMPLATE_TIMESTAMP, formatLogTimestamp, resolveLogPath, slugifyModelName, } from './logs.ts';
-export { EngineAdapter } from './adapter.ts';
-export type { BuildMode, DeployOptions, DeployResult, EngineLaunchState, EnginePlatformConfig, FetchResult, HealthCheckOptions, HealthResult, LaunchPlan, LaunchProgress, LaunchStep, LifecycleHost, ProcessExitInfo, ProcessHandle, } from './adapter.ts';
+export { DEFAULT_LOG_PATH_TEMPLATE, LOG_FILE_NAME_TEMPLATE, LOG_TAIL_BYTES, LOG_TEMPLATE_ENGINE, LOG_TEMPLATE_HOME, LOG_TEMPLATE_MODEL, LOG_TEMPLATE_TIMESTAMP, formatLogTimestamp, resolveLogPath, slugifyModelName, } from './logs.ts';
+export { COMMAND_LOG_PREFIX, EngineAdapter, LAUNCH_STEPS, URL_LOG_PREFIX, autoRebuildEnabled, commandLogLine, urlLogLine, } from './adapter.ts';
+export type { BuildMode, CommandLogger, DeployOptions, DeployResult, EngineLaunchState, EnginePlatformConfig, FetchResult, HealthCheckOptions, HealthResult, LaunchPlan, LaunchProgress, LaunchStep, LifecycleHost, ProcessExitInfo, ProcessHandle, RunOptions, } from './adapter.ts';
 export { NOOP_DEBUG_LOGGER, createCommandDebugLogger, isHarnessLogDebug, } from './debug.ts';
 export type { CreateCommandDebugLoggerArgs, DebugLogger, } from './debug.ts';
 export { constraintId, evaluateGuidelines, modelGuidelines } from './guideline.ts';
 export type { Guideline, GuidelineLevel, GuidelineResult } from './guideline.ts';
 export { hardwareClass, presetFromFetch, resolveDefaults, WILDCARD_HARDWARE_CLASS, } from './defaults.ts';
 export type { DefaultProvenance, DefaultsResolver, HardwareClass, Preset, PresetSource, ResolvedDefaults, } from './defaults.ts';
-export { AGENT_DEFAULT_MODEL_NAMESPACE, agentDefaultOps, agentDefaultPointsAt, agentDefaultUnsetOps, apiKeyEnvFor, buildModelEntry, LLM_PI_AI_NAMESPACE, modelRowsFrom, modelSlug, providerIdFor, providerRegistrationOps, providerRemovalOps, removeModelRow, upsertModelRow, } from './registrar.ts';
+export { AGENT_DEFAULT_MODEL_NAMESPACE, agentDefaultOps, agentDefaultPointsAt, agentDefaultUnsetOps, apiKeyEnvFor, buildModelEntry, defaultApiKeyFor, LLM_PI_AI_NAMESPACE, modelRowsFrom, modelSlug, providerIdFor, providerRegistrationOps, providerRemovalOps, removeModelRow, upsertModelRow, } from './registrar.ts';
 export type { DshModelEntry, DshModelRegistrar, ModelRow, RegisterResult, SettingsOp, } from './registrar.ts';
-export { checkDeps, detectPackageManager, planDeps, renderInstallString, runInstall, } from './deps.ts';
-export { CHAT_TEMPLATE_FILE, hfChatTemplateCommand, hfDownloadCommand, modelArtifactPath, modelEntriesForEngine, repoIdFromUrl, repoNameFromUrl, } from './models.ts';
-export type { DefaultModel, ModelDirectoryEntry } from './models.ts';
+export { checkDeps, detectPackageManager, osLabel, planDeps, renderInstallString, runInstall, } from './deps.ts';
+export { guardSudoCommand, sudoFailureDetail, SUDO_CLI_NOTE, SUDO_PASSWORD_TIMEOUT_MS, SUDO_PROBE_COMMAND, } from './sudo.ts';
+export type { SudoGuard, SudoGuardOptions, SudoTimer } from './sudo.ts';
+export { CHAT_TEMPLATE_FILE, chatTemplateArtifactPath, chatTemplatePresent, hfChatTemplateCommand, hfDownloadCommand, hfDownloadFileCommand, hubCacheModelDirectory, hubCacheSnapshotFilePath, isModelDirectoryOverridden, modelArtifactPath, modelArtifactPresent, modelCacheEntriesForEngine, modelEntriesForEngine, repoIdFromUrl, repoNameFromUrl, } from './models.ts';
+export type { DefaultModel, ModelCacheEntry, ModelDirectoryEntry, ModelDownloadSource, } from './models.ts';
+export { hfDatasetsCacheDirectory, hfHubCacheDirectory, modelDownloadTarget, resolveModelDirectory, } from './hf-cache.ts';
+export type { ModelDirectoryResolution, ModelDownloadTarget } from './hf-cache.ts';
+export { dshConfigCacheDirectory, dshEngineCacheDirectory, dshInferCacheDirectory, hfDownloadResultDirectory, } from './infer-cache.ts';
+export { foldHfProgressChunk, parseHfProgressLine } from './progress.ts';
+export type { HfProgress } from './progress.ts';
 export type { CommandOutcome, CommandRunner, DepCheck, DepStatus, EngineDepPlan, InstallCommands, InstallResult, PackageManager, PackageManagerProbes, SystemDep, SystemDepProvisioner, } from './deps.ts';
-//# sourceMappingURL=index.d.ts.map
+//# sourceMappingURL=index.d.ts.map

package/packages/core/lib/index.js

@@ -11,12 +11,16 @@ export { GPU_USAGE_BUSY_THRESHOLD, matchLaunchSignature, parseNvidiaSmiGpuUsage,
 export { commandMatchesArgv, launchRecordFromPlan, reLinkRecord, } from "./launch-record.js";
 export { formatLaunchCommand } from "./launch-command.js";
 export { computeProviderStatuses, isGpuBusy, } from "./status.js";
-export { DEFAULT_LOG_PATH_TEMPLATE, LOG_FILE_NAME_TEMPLATE, LOG_TEMPLATE_ENGINE, LOG_TEMPLATE_HOME, LOG_TEMPLATE_MODEL, LOG_TEMPLATE_TIMESTAMP, formatLogTimestamp, resolveLogPath, slugifyModelName, } from "./logs.js";
-export { EngineAdapter } from "./adapter.js";
+export { DEFAULT_LOG_PATH_TEMPLATE, LOG_FILE_NAME_TEMPLATE, LOG_TAIL_BYTES, LOG_TEMPLATE_ENGINE, LOG_TEMPLATE_HOME, LOG_TEMPLATE_MODEL, LOG_TEMPLATE_TIMESTAMP, formatLogTimestamp, resolveLogPath, slugifyModelName, } from "./logs.js";
+export { COMMAND_LOG_PREFIX, EngineAdapter, LAUNCH_STEPS, URL_LOG_PREFIX, autoRebuildEnabled, commandLogLine, urlLogLine, } from "./adapter.js";
 export { NOOP_DEBUG_LOGGER, createCommandDebugLogger, isHarnessLogDebug, } from "./debug.js";
 export { constraintId, evaluateGuidelines, modelGuidelines } from "./guideline.js";
 export { hardwareClass, presetFromFetch, resolveDefaults, WILDCARD_HARDWARE_CLASS, } from "./defaults.js";
-export { AGENT_DEFAULT_MODEL_NAMESPACE, agentDefaultOps, agentDefaultPointsAt, agentDefaultUnsetOps, apiKeyEnvFor, buildModelEntry, LLM_PI_AI_NAMESPACE, modelRowsFrom, modelSlug, providerIdFor, providerRegistrationOps, providerRemovalOps, removeModelRow, upsertModelRow, } from "./registrar.js";
-export { checkDeps, detectPackageManager, planDeps, renderInstallString, runInstall, } from "./deps.js";
-export { CHAT_TEMPLATE_FILE, hfChatTemplateCommand, hfDownloadCommand, modelArtifactPath, modelEntriesForEngine, repoIdFromUrl, repoNameFromUrl, } from "./models.js";
-//# sourceMappingURL=index.js.map
+export { AGENT_DEFAULT_MODEL_NAMESPACE, agentDefaultOps, agentDefaultPointsAt, agentDefaultUnsetOps, apiKeyEnvFor, buildModelEntry, defaultApiKeyFor, LLM_PI_AI_NAMESPACE, modelRowsFrom, modelSlug, providerIdFor, providerRegistrationOps, providerRemovalOps, removeModelRow, upsertModelRow, } from "./registrar.js";
+export { checkDeps, detectPackageManager, osLabel, planDeps, renderInstallString, runInstall, } from "./deps.js";
+export { guardSudoCommand, sudoFailureDetail, SUDO_CLI_NOTE, SUDO_PASSWORD_TIMEOUT_MS, SUDO_PROBE_COMMAND, } from "./sudo.js";
+export { CHAT_TEMPLATE_FILE, chatTemplateArtifactPath, chatTemplatePresent, hfChatTemplateCommand, hfDownloadCommand, hfDownloadFileCommand, hubCacheModelDirectory, hubCacheSnapshotFilePath, isModelDirectoryOverridden, modelArtifactPath, modelArtifactPresent, modelCacheEntriesForEngine, modelEntriesForEngine, repoIdFromUrl, repoNameFromUrl, } from "./models.js";
+export { hfDatasetsCacheDirectory, hfHubCacheDirectory, modelDownloadTarget, resolveModelDirectory, } from "./hf-cache.js";
+export { dshConfigCacheDirectory, dshEngineCacheDirectory, dshInferCacheDirectory, hfDownloadResultDirectory, } from "./infer-cache.js";
+export { foldHfProgressChunk, parseHfProgressLine } from "./progress.js";
+//# sourceMappingURL=index.js.map

package/packages/core/lib/infer-cache.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Infer cache directory resolution: the plugin-owned locations under the user
+ * home where engine checkouts live and engine config files land. One module
+ * owns every `~/.cache/dsh/infer` path so adapters, routes, and view models
+ * consume these builders instead of restating the literal. Models stay
+ * outside it: the hub cache remains the model download home.
+ * @module dsh-plugin-local-infer/core/infer-cache
+ */
+/**
+ * dshInferCacheDirectory is the plugin's cache root:
+ * `~/.cache/dsh/infer`. Engine checkouts and engine config files live under
+ * it; model downloads do not.
+ */
+export declare function dshInferCacheDirectory(): string;
+/**
+ * dshEngineCacheDirectory is the default checkout home for one engine:
+ * `~/.cache/dsh/infer/{engineId}` (e.g. `~/.cache/dsh/infer/basalt`). One
+ * checkout per engine, never a subfolder of a model directory.
+ */
+export declare function dshEngineCacheDirectory(engineId: string): string;
+/**
+ * dshConfigCacheDirectory is the default home for engine config files the
+ * plugin writes: `~/.cache/dsh/infer/config`. Engines that require a
+ * specific placement are the exception; every other config file lands here
+ * (in a per-engine subdirectory, which the caller composes).
+ */
+export declare function dshConfigCacheDirectory(): string;
+/**
+ * hfDownloadResultDirectory is the directory the hf CLI's hub-cache download
+ * of one repo file lands in: the snapshot directory under
+ * `models--{ns}--{name}/snapshots/` that holds the artifact, resolved
+ * through hubCacheSnapshotFilePath. Returns null when the artifact is not in
+ * the cache, which the caller reads as "fall back to the hub cache root as
+ * the download base". A blank `file` names no artifact (a whole-repo
+ * download has no single snapshot directory to name), so it resolves to null
+ * for the same fallback.
+ */
+export declare function hfDownloadResultDirectory(hubCache: string, repoId: string, file: string): string | null;
+//# sourceMappingURL=infer-cache.d.ts.map

package/packages/core/lib/infer-cache.js

@@ -0,0 +1,53 @@
+/**
+ * Infer cache directory resolution: the plugin-owned locations under the user
+ * home where engine checkouts live and engine config files land. One module
+ * owns every `~/.cache/dsh/infer` path so adapters, routes, and view models
+ * consume these builders instead of restating the literal. Models stay
+ * outside it: the hub cache remains the model download home.
+ * @module dsh-plugin-local-infer/core/infer-cache
+ */
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { hubCacheSnapshotFilePath } from "./models.js";
+/**
+ * dshInferCacheDirectory is the plugin's cache root:
+ * `~/.cache/dsh/infer`. Engine checkouts and engine config files live under
+ * it; model downloads do not.
+ */
+export function dshInferCacheDirectory() {
+    return join(homedir(), '.cache', 'dsh', 'infer');
+}
+/**
+ * dshEngineCacheDirectory is the default checkout home for one engine:
+ * `~/.cache/dsh/infer/{engineId}` (e.g. `~/.cache/dsh/infer/basalt`). One
+ * checkout per engine, never a subfolder of a model directory.
+ */
+export function dshEngineCacheDirectory(engineId) {
+    return join(dshInferCacheDirectory(), engineId);
+}
+/**
+ * dshConfigCacheDirectory is the default home for engine config files the
+ * plugin writes: `~/.cache/dsh/infer/config`. Engines that require a
+ * specific placement are the exception; every other config file lands here
+ * (in a per-engine subdirectory, which the caller composes).
+ */
+export function dshConfigCacheDirectory() {
+    return join(dshInferCacheDirectory(), 'config');
+}
+/**
+ * hfDownloadResultDirectory is the directory the hf CLI's hub-cache download
+ * of one repo file lands in: the snapshot directory under
+ * `models--{ns}--{name}/snapshots/` that holds the artifact, resolved
+ * through hubCacheSnapshotFilePath. Returns null when the artifact is not in
+ * the cache, which the caller reads as "fall back to the hub cache root as
+ * the download base". A blank `file` names no artifact (a whole-repo
+ * download has no single snapshot directory to name), so it resolves to null
+ * for the same fallback.
+ */
+export function hfDownloadResultDirectory(hubCache, repoId, file) {
+    if (file === '')
+        return null;
+    const path = hubCacheSnapshotFilePath(hubCache, repoId, file);
+    return path === null ? null : dirname(path);
+}
+//# sourceMappingURL=infer-cache.js.map

package/packages/core/lib/launch-command.d.ts

@@ -6,8 +6,12 @@ import type { LaunchPlan } from './adapter.ts';
  * card's Logs section shows the line above the engine's own output, so a
  * user can read and copy the exact binary and arguments a launch started
  * with. The Hyper-Qwen deploy runs this same string, so the printed line and
- * the host command cannot drift. Returns undefined when the plan names no
- * command (a non-compose plan with no argv).
+ * the host command cannot drift. The optional autoRebuild is the card's Auto
+ * Rebuild checkbox as the deploy reads it: absent or true renders the
+ * default `--pull always` (the up step re-pulls the image), false renders
+ * `--pull missing` (the up step starts the already-present image), the same
+ * skip rule the pull-guarded docker adapters follow. Returns undefined when
+ * the plan names no command (a non-compose plan with no argv).
  */
-export declare function formatLaunchCommand(plan: LaunchPlan): string | undefined;
-//# sourceMappingURL=launch-command.d.ts.map
+export declare function formatLaunchCommand(plan: LaunchPlan, autoRebuild?: boolean): string | undefined;
+//# sourceMappingURL=launch-command.d.ts.map

package/packages/core/lib/launch-command.js

@@ -1,3 +1,4 @@
+import { autoRebuildEnabled } from "./adapter.js";
 /**
  * formatLaunchCommand renders a launch plan as the shell command string the
  * deploy step runs to start the engine: the quoted argv joined for a process
@@ -5,10 +6,14 @@
  * card's Logs section shows the line above the engine's own output, so a
  * user can read and copy the exact binary and arguments a launch started
  * with. The Hyper-Qwen deploy runs this same string, so the printed line and
- * the host command cannot drift. Returns undefined when the plan names no
- * command (a non-compose plan with no argv).
+ * the host command cannot drift. The optional autoRebuild is the card's Auto
+ * Rebuild checkbox as the deploy reads it: absent or true renders the
+ * default `--pull always` (the up step re-pulls the image), false renders
+ * `--pull missing` (the up step starts the already-present image), the same
+ * skip rule the pull-guarded docker adapters follow. Returns undefined when
+ * the plan names no command (a non-compose plan with no argv).
  */
-export function formatLaunchCommand(plan) {
+export function formatLaunchCommand(plan, autoRebuild) {
     if (plan.kind === 'compose') {
         // The user's compose arguments (the card's docker-tag field) override the
         // default profile: the flags the up step runs before the required `up -d`.
@@ -29,7 +34,9 @@ export function formatLaunchCommand(plan) {
                 .join(' ');
         }
         // The compose defaults match the adapter's renderLaunch fallbacks, so a
-        // plan built from a bare config still spells a runnable command.
+        // plan built from a bare config still spells a runnable command. Auto
+        // Rebuild off keeps the image acquisition out of the up step: compose
+        // starts the already-present image with the plan's parameters.
         return [
             'docker',
             'compose',
@@ -39,7 +46,7 @@ export function formatLaunchCommand(plan) {
             plan.profile ?? 'single',
             'up',
             '--pull',
-            'always',
+            autoRebuildEnabled(autoRebuild) ? 'always' : 'missing',
             '-d',
         ]
             .map(quoteArg)
@@ -61,4 +68,4 @@ function quoteArg(token) {
         return token;
     return `'${token.replaceAll("'", "'\\''")}'`;
 }
-//# sourceMappingURL=launch-command.js.map
+//# sourceMappingURL=launch-command.js.map

package/packages/core/lib/launch-record.d.ts

@@ -80,4 +80,4 @@ export declare function commandMatchesArgv(command: string, argv: readonly strin
  * restart, and the cap keeps the record bounded).
  */
 export declare function launchRecordFromPlan(plan: LaunchPlan, pid: number, parentPid: number | undefined, previousPids: readonly number[]): ProviderLaunchRecord;
-//# sourceMappingURL=launch-record.d.ts.map
+//# sourceMappingURL=launch-record.d.ts.map

package/packages/core/lib/launch-record.js

@@ -77,4 +77,4 @@ export function launchRecordFromPlan(plan, pid, parentPid, previousPids) {
     }
     return record;
 }
-//# sourceMappingURL=launch-record.js.map
+//# sourceMappingURL=launch-record.js.map

package/packages/core/lib/logs.d.ts

@@ -5,6 +5,13 @@
  * not a shell expansion the plugin performs.
  */
 export declare const DEFAULT_LOG_PATH_TEMPLATE = "${HOME}/.dsh/local-infer/logs";
+/**
+ * LOG_TAIL_BYTES is the tail cap on captured log text: the stored last-run
+ * logs, a spawned engine's accumulated output, and an appended run all keep
+ * only the last 64 KiB, so a chatty engine or a long build cannot grow the
+ * config file or the host's memory without bound.
+ */
+export declare const LOG_TAIL_BYTES = 65536;
 /**
  * LOG_FILE_NAME_TEMPLATE is the fixed file name a launch's log file carries,
  * inside the user-edited log directory. The placeholders resolve against the
@@ -41,4 +48,4 @@ export declare function formatLogTimestamp(date: Date): string;
  * its own file inside the directory. A directory with no ${HOME} is used as-is.
  */
 export declare function resolveLogPath(directory: string, engineId: string, modelId: string | undefined, date: Date, home: string): string;
-//# sourceMappingURL=logs.d.ts.map
+//# sourceMappingURL=logs.d.ts.map

package/packages/core/lib/logs.js

@@ -4,7 +4,15 @@
  * from the fixed file-name template below. ${HOME} is the host home directory,
  * not a shell expansion the plugin performs.
  */
+import { join } from 'node:path';
 export const DEFAULT_LOG_PATH_TEMPLATE = '${HOME}/.dsh/local-infer/logs';
+/**
+ * LOG_TAIL_BYTES is the tail cap on captured log text: the stored last-run
+ * logs, a spawned engine's accumulated output, and an appended run all keep
+ * only the last 64 KiB, so a chatty engine or a long build cannot grow the
+ * config file or the host's memory without bound.
+ */
+export const LOG_TAIL_BYTES = 65_536;
 /**
  * LOG_FILE_NAME_TEMPLATE is the fixed file name a launch's log file carries,
  * inside the user-edited log directory. The placeholders resolve against the
@@ -64,8 +72,8 @@ export function resolveLogPath(directory, engineId, modelId, date, home) {
         .replace(LOG_TEMPLATE_ENGINE, engineId)
         .replace(LOG_TEMPLATE_MODEL, slugifyModelName(modelId))
         .replace(LOG_TEMPLATE_TIMESTAMP, formatLogTimestamp(date));
-    // A directory that already ends in a separator does not double it.
-    const dir = resolvedDir.endsWith('/') ? resolvedDir : `${resolvedDir}/`;
-    return `${dir}${fileName}`;
+    // join normalizes the separators and does not double a trailing one, so the
+    // result is a clean path on every platform.
+    return join(resolvedDir, fileName);
 }
-//# sourceMappingURL=logs.js.map
+//# sourceMappingURL=logs.js.map

package/packages/core/lib/models.d.ts

@@ -14,6 +14,14 @@ export interface DefaultModel {
     url: string;
     file?: string;
 }
+/**
+ * ModelDownloadSource is the half of a DefaultModel the presence check, the
+ * hf CLI command, and the hub-cache lookup read: the Hugging Face repo URL
+ * and the optional artifact file. A full list entry satisfies it, and an
+ * adapter that only resolves the download pair composes just these fields
+ * instead of restating the entry's inert registry data.
+ */
+export type ModelDownloadSource = Pick<DefaultModel, 'url' | 'file'>;
 /**
  * repoIdFromUrl turns a Hugging Face repo URL into the `owner/name` repo id
  * the hf CLI takes. A URL with no owner/name pair reads as an empty id, which
@@ -27,18 +35,57 @@ export declare function repoIdFromUrl(url: string): string;
  */
 export declare function repoNameFromUrl(url: string): string;
 /**
- * modelArtifactPath is the path the presence check looks for in the model
- * directory: the entry's artifact file when it names one, else the repo-name
- * directory a whole-repo download leaves behind.
+ * hubCacheModelDirectory is the per-model directory the hf CLI creates in the
+ * hub cache for one repo id: `models--{namespace}--{name}`. A repo id without
+ * an owner/name pair reads as an empty directory name, which the callers
+ * handle as an absent model.
+ */
+export declare function hubCacheModelDirectory(repoId: string): string;
+/**
+ * isModelDirectoryOverridden reports whether a model directory field (the
+ * config's or a download request's) names a path (a non-blank string), the
+ * one rule every download route and view model shares to decide the layout:
+ * a named directory targets that directory flat (`--local-dir`), an unnamed
+ * one takes the hub-cache layout (no `--local-dir`, the
+ * `models--{ns}--{name}` directories the hf CLI writes into the hub cache).
+ * The predicate form lets callers narrow the field to a string without
+ * restating the blank check.
+ */
+export declare function isModelDirectoryOverridden(modelDirectory: unknown): modelDirectory is string;
+/**
+ * modelArtifactPath is the path a model download's artifact lands at in the
+ * model directory: the entry's artifact file when it names one, else the
+ * repo-name directory a whole-repo download leaves behind. With the hub-cache
+ * layout (`useHubCache`), it resolves into the per-model cache directory's
+ * `blobs` folder, the content-addressed store the hf CLI writes without
+ * `--local-dir`; the `directory` is then the hub cache root, not the per-model
+ * folder. Every presence decision (the card-facing checks and the engines'
+ * deploy re-fetch gates) resolves the deterministic snapshot instead
+ * (modelArtifactPresent); the hub-cache form here stays the blobs-store path.
  */
-export declare function modelArtifactPath(entry: DefaultModel, directory: string): string;
+export declare function modelArtifactPath(entry: ModelDownloadSource, directory: string, useHubCache?: boolean): string;
 /**
- * hfDownloadCommand renders the hf CLI download for one default model: the
- * repo, the artifact file when the entry names one, and the `--local-dir`
- * target. The string is the single source the download route runs and the
- * card shows beside its Download button.
+ * hfDownloadFileCommand renders the hf CLI download for one repo and file
+ * pair: the repo, the file (omitted when blank, a whole-repo download), the
+ * `--local-dir` target when the hub-cache layout does not apply, and the
+ * `--format human` flag. The flag overrides the non-TTY default (`auto` picks
+ * `agent`, which prints no progress) so the hf CLI prints tqdm progress
+ * lines to stderr, which the progress streaming tasks consume. The string is
+ * the single source every hf download command renders through: the model and
+ * chat-template builders below, and the Infernix extra-download commands the
+ * Get step streams.
  */
-export declare function hfDownloadCommand(entry: DefaultModel, directory: string): string;
+export declare function hfDownloadFileCommand(repo: string, file: string, directory: string, useHubCache?: boolean): string;
+/**
+ * hfDownloadCommand renders the hf CLI download for one model download
+ * source: the repo, the artifact file when the entry names one, and the
+ * `--local-dir` target. With the hub-cache layout (`useHubCache`), the `--local-dir` is
+ * dropped so the hf CLI writes into the hub cache's `models--{ns}--{name}`
+ * directory (the content-addressed `blobs/` plus the `snapshots/`). The
+ * string is the single source the download route runs and the card shows
+ * beside its Download button, rendered through hfDownloadFileCommand.
+ */
+export declare function hfDownloadCommand(entry: ModelDownloadSource, directory: string, useHubCache?: boolean): string;
 /**
  * The chat template file the hf CLI pulls into the model directory. The
  * NInfer deploy step and the template download route both target this name, so
@@ -48,11 +95,50 @@ export declare const CHAT_TEMPLATE_FILE = "chat_template.jinja";
 /**
  * hfChatTemplateCommand renders the hf CLI download for one chat template repo
  * reference into the model directory: the repo, the template file, and the
- * `--local-dir` target. The string is the single source the template download
- * route runs and the card shows beside its Download button and in the System
- * dependencies box when the auto-download is unavailable.
+ * `--local-dir` target. With the hub-cache layout (`useHubCache`), the
+ * `--local-dir` is dropped so the template lands in the hub cache's
+ * `models--{ns}--{name}` directory. The string is the single source the
+ * template download route runs and the card shows beside its Download button
+ * and in the System dependencies box when the auto-download is unavailable,
+ * rendered through hfDownloadFileCommand.
  */
-export declare function hfChatTemplateCommand(repo: string, directory: string): string;
+export declare function hfChatTemplateCommand(repo: string, directory: string, useHubCache?: boolean): string;
+/**
+ * chatTemplateArtifactPath is the path the flat-layout chat-template presence
+ * check looks for: the template file joined onto the model directory. The
+ * hub-cache layout resolves through chatTemplatePresent instead (the
+ * deterministic snapshot pick), not through this join.
+ */
+export declare function chatTemplateArtifactPath(directory: string): string;
+/**
+ * modelArtifactPresent reports whether a model download source's artifact is
+ * on disk. With the hub-cache layout it resolves the deterministic hub-cache
+ * snapshot holding the file (the same pick the model-directory display uses),
+ * so a `blobs` folder left by any download never reads as present on its
+ * own; a blank `file` (a whole-repo download) reads the repo's snapshot
+ * directories. With the flat layout it checks the artifact path joined onto
+ * the base directory. `baseDir` is the hub cache root under the cache layout,
+ * the flat override otherwise.
+ */
+export declare function modelArtifactPresent(entry: ModelDownloadSource, baseDir: string, useHubCache?: boolean): boolean;
+/**
+ * chatTemplatePresent reports whether a chat template repo's template file is
+ * on disk: the deterministic hub-cache snapshot pick under the hub-cache
+ * layout (a per-repo `snapshots` folder alone never reads as present), the
+ * flat file join otherwise. `baseDir` follows the modelArtifactPresent rule.
+ */
+export declare function chatTemplatePresent(repo: string, baseDir: string, useHubCache?: boolean): boolean;
+/**
+ * hubCacheSnapshotFilePath resolves the concrete file path of one file in the
+ * hub cache's snapshots, matching what the hf CLI treats as the active
+ * revision: the commit recorded in `refs/main` wins when its directory under
+ * `models--{ns}--{name}/snapshots/` holds the file; otherwise the snapshot
+ * with the newest mtime wins, covering a repo with no ref and a ref naming a
+ * commit that lacks the file. Ties break on readdir order. Returns null when
+ * no snapshot holds the file (the file is not downloaded), which the caller
+ * reads as absent. The `hubCache` is the hub cache root.
+ */
+export declare function hubCacheSnapshotFilePath(hubCache: string, repoId: string, file: string): string | null;
 /**
  * ModelDirectoryEntry is one top-level entry of a model directory listing:
  * the entry name, whether it is a directory, and for directories whether the
@@ -74,4 +160,24 @@ export interface ModelDirectoryEntry {
  * sorted, so the dropdown order is stable across summary fetches.
  */
 export declare function modelEntriesForEngine(entries: readonly ModelDirectoryEntry[], engineId: string): string[];
-//# sourceMappingURL=models.d.ts.map
+/**
+ * ModelCacheEntry is one `models--*` directory in the hub cache: the repo id
+ * the directory names (the `{namespace}/{name}` decoded from the
+ * `models--{ns}--{name}` form) and the artifact file names the snapshots hold
+ * (the union across every commit), the data the per-engine cache scan filters.
+ */
+export interface ModelCacheEntry {
+    repoId: string;
+    files: string[];
+}
+/**
+ * modelCacheEntriesForEngine filters the hub cache's `models--*` directories
+ * down to the models the engine's Model dropdown offers, by the artifact types
+ * each engine serves: Basalt `.basalt`, NInfer `.ninfer`, Infernix
+ * `.ninfer`/`.infernix`, llama.cpp `.gguf`, Hyper-Qwen a repo holding a
+ * `.safetensors` weight file, and Strata `.gguf`/`.safetensors`. An engine with
+ * no matching cached model lists none. The result is the repo ids the
+ * dropdown shows, sorted for a stable order across summary fetches.
+ */
+export declare function modelCacheEntriesForEngine(entries: readonly ModelCacheEntry[], engineId: string): string[];
+//# sourceMappingURL=models.d.ts.map