dsh-plugin-local-infer 0.1.3 → 0.1.4

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

@@ -0,0 +1,117 @@
+/**
+ * The GET /local-infer/logs route: the per-provider live run-log stream the
+ * card's Logs pane holds open (Q2: all live log display streams, nothing
+ * polls). The handler subscribes to the run-log hub before reading the
+ * catch-up snapshot, so an append that lands between the two is deduped by
+ * seq against the snapshot instead of doubling or being lost. One attached
+ * connection sees, in order: one `{ snapshot, seq, running }` catch-up line,
+ * then one `{ log, seq }` line per append, a `{ runBegin, seq }` line when a
+ * new run resets the buffer (the pane replaces, never appends), and a
+ * `{ runEnd, seq }` line when the run settles. The connection stays attached
+ * across runs. An unknown or blank provider key streams the empty snapshot
+ * and stays attached, so a client racing a run start never sees a 404; the
+ * client disconnect disposes the hub subscription.
+ * @module dsh-plugin-local-infer/ui/routes/logs
+ */
+import { defineRoute } from "../route.js";
+import { ndjsonLine } from "./stream.js";
+/**
+ * logsRoute builds the GET /local-infer/logs?provider=<key> route definition
+ * the register step holds by an effect. The `provider` query is the run key
+ * every run path shares (the runLogKey rule the card's requests mirror); a
+ * missing or unknown key is a live stream of nothing until someone runs it.
+ */
+export function logsRoute(localInfer) {
+    // One closer per attached connection, so the effect disposer can detach
+    // every stream still open when the bundle switches off.
+    const openConnections = new Set();
+    const route = defineRoute({
+        name: 'local-infer-logs',
+        path: '/local-infer/logs',
+        method: 'GET',
+        failStatus: 500,
+        run: async ({ url }, res) => {
+            res.ndjsonStream();
+            const key = url.searchParams.get('provider') ?? '';
+            // The highest hub seq the client's text already covers: the snapshot
+            // line, then every forwarded log append. A log event at or below it is
+            // already in text the client holds, so it is dropped.
+            let coveredSeq = 0;
+            // True until the snapshot line is on the wire. Hub events that land in
+            // the window between subscribe and the snapshot read queue here and
+            // then run through the same seq rule, so the snapshot is always the
+            // stream's first line.
+            let catchingUp = true;
+            const queued = [];
+            // A client disconnect stops forwarding before the hub hands another
+            // event to a write on the closed response.
+            let closed = false;
+            const forward = (event) => {
+                if (event.kind === 'log') {
+                    if (event.seq <= coveredSeq)
+                        return;
+                    coveredSeq = event.seq;
+                    ndjsonLine(res, { log: event.text, seq: event.seq });
+                    return;
+                }
+                if (event.kind === 'reset') {
+                    // A new run restarted the key's seq at 0 with the seed line; the
+                    // pane replaces its buffer, and the seq count restarts with it.
+                    coveredSeq = event.seq;
+                    ndjsonLine(res, { runBegin: event.text, seq: event.seq });
+                    return;
+                }
+                ndjsonLine(res, { runEnd: true, seq: event.seq });
+            };
+            // Subscribe first, then read: an append racing between the two is
+            // caught by the listener (queued) and deduped against the snapshot
+            // that already holds its text, never lost or doubled.
+            const dispose = localInfer.subscribeRunLog(key, (event) => {
+                if (closed)
+                    return;
+                if (catchingUp) {
+                    queued.push(event);
+                    return;
+                }
+                forward(event);
+            });
+            const snapshot = localInfer.readRunLog(key);
+            coveredSeq = snapshot.seq;
+            ndjsonLine(res, {
+                snapshot: snapshot.text,
+                seq: snapshot.seq,
+                running: snapshot.running,
+            });
+            catchingUp = false;
+            for (const event of queued) {
+                forward(event);
+            }
+            // The bundle switching off while this pane still streams: end the
+            // response and drop the hub subscription, so no listener outlives the
+            // route it was opened by (the effect disposer runs closeOpenStreams).
+            const closeConnection = () => {
+                closed = true;
+                dispose();
+                openConnections.delete(closeConnection);
+                res.end();
+            };
+            openConnections.add(closeConnection);
+            // The card unmounting or refreshing closes the response: dispose the
+            // subscription so a gone pane never leaves a listener behind.
+            res.onClose(() => {
+                closed = true;
+                dispose();
+                openConnections.delete(closeConnection);
+            });
+        },
+    });
+    return {
+        ...route,
+        closeOpenStreams() {
+            for (const closeConnection of [...openConnections]) {
+                closeConnection();
+            }
+        },
+    };
+}
+//# sourceMappingURL=logs.js.map

package/packages/ui/lib/routes/provider-delete.d.ts

@@ -12,4 +12,4 @@ import type { LocalInferRoute } from '../route.ts';
  * definition the register step holds by an effect.
  */
 export declare function providerDeleteRoute(localInfer: LocalInferService): LocalInferRoute;
-//# sourceMappingURL=provider-delete.d.ts.map
+//# sourceMappingURL=provider-delete.d.ts.map

package/packages/ui/lib/routes/provider-delete.js

@@ -34,4 +34,4 @@ export function providerDeleteRoute(localInfer) {
         },
     });
 }
-//# sourceMappingURL=provider-delete.js.map
+//# sourceMappingURL=provider-delete.js.map

package/packages/ui/lib/routes/register.d.ts

@@ -13,4 +13,4 @@ import type { LocalInferRoute } from '../route.ts';
  * register step holds by an effect.
  */
 export declare function registerRoute(localInfer: LocalInferService): LocalInferRoute;
-//# sourceMappingURL=register.d.ts.map
+//# sourceMappingURL=register.d.ts.map

package/packages/ui/lib/routes/register.js

@@ -25,4 +25,4 @@ export function registerRoute(localInfer) {
         },
     });
 }
-//# sourceMappingURL=register.js.map
+//# sourceMappingURL=register.js.map

package/packages/ui/lib/routes/save.d.ts

@@ -15,4 +15,4 @@ import type { LocalInferRoute } from '../route.ts';
  * step holds by an effect.
  */
 export declare function saveRoute(localInfer: LocalInferService): LocalInferRoute;
-//# sourceMappingURL=save.d.ts.map
+//# sourceMappingURL=save.d.ts.map

package/packages/ui/lib/routes/save.js

@@ -44,6 +44,20 @@ export function saveRoute(localInfer) {
             // A body that omits the log location (or sends a blank one) keeps the
             // stored template, so an unsaved edit never wipes a custom path.
             const logPath = typeof body.logPath === 'string' && body.logPath !== '' ? body.logPath : stored.logPath;
+            // The card's Auto Rebuild checkbox arrives as a body boolean; a body
+            // that omits the key (or carries a non-boolean) reads as absent so the
+            // upsert keeps the stored entry's flag instead of dropping it.
+            const autoRebuild = typeof body.autoRebuild === 'boolean' ? body.autoRebuild : undefined;
+            // carryAutoRebuild writes the Auto Rebuild flag onto an upserted
+            // entry: the body's boolean wins, a body that omits the key carries
+            // the stored entry's flag over, and an entry with neither keeps no key
+            // (the card draws the box unchecked, so no migration is needed).
+            const carryAutoRebuild = (provider, storedFlag) => {
+                const flag = autoRebuild ?? storedFlag;
+                if (flag !== undefined) {
+                    provider.autoRebuild = flag;
+                }
+            };
             // Save upserts a provider entry: an id updates the stored entry in
             // place, an absent id updates a stored entry that already matches the
             // engine, config, and platform in place, and only a save with no match
@@ -53,7 +67,9 @@ export function saveRoute(localInfer) {
             // per-engine entry the deploy step reads, so a provider never carries a
             // field it cannot price. A save that updates an entry in place carries
             // the entry's launch record over, so editing a running provider's config
-            // never drops the record the restart re-link prices. A settings-only
+            // never drops the record the restart re-link prices, and carries the
+            // entry's Auto Rebuild flag over when the body omits it, so an old save
+            // caller never drops a stored checkbox value. A settings-only
             // save skips the upsert: it persists the global fields the toggle edits
             // and keeps the stored list intact, so the help and allow-run toggles
             // never mint a duplicate entry.
@@ -72,6 +88,7 @@ export function saveRoute(localInfer) {
                     config,
                     platform: platform[engine] ?? {},
                 };
+                carryAutoRebuild(provider, existing?.autoRebuild);
                 if (existing?.launch !== undefined) {
                     provider.launch = existing.launch;
                 }
@@ -94,6 +111,7 @@ export function saveRoute(localInfer) {
                         config,
                         platform: platformConfig,
                     };
+                    carryAutoRebuild(provider, matching.autoRebuild);
                     if (matching.launch !== undefined) {
                         provider.launch = matching.launch;
                     }
@@ -106,6 +124,8 @@ export function saveRoute(localInfer) {
                         config,
                         platform: platformConfig,
                     };
+                    // A brand-new entry with no body key stays without the key.
+                    carryAutoRebuild(provider, undefined);
                     providers = [provider, ...stored.providers];
                 }
             }
@@ -136,4 +156,4 @@ export function saveRoute(localInfer) {
         },
     });
 }
-//# sourceMappingURL=save.js.map
+//# sourceMappingURL=save.js.map

package/packages/ui/lib/routes/stop.d.ts

@@ -1,9 +1,12 @@
 /**
  * The POST /local-infer/stop route: it renders the same plan the launch
  * rendered and runs the service's stop entry point, so the stop targets the
- * exact container or process the launch started. The stop then clears the
- * target entry's launch record, so a recycled pid cannot re-link an engine
- * the user just stopped.
+ * exact container or process the launch started (a re-adopted engine through
+ * the record's pid). The stop then clears the target entry's launch record,
+ * so a recycled pid cannot re-link an engine the user just stopped. A stop
+ * that fails persists a note to the last-run logs and the log file and
+ * answers 500, so the card's stop deadline settles the entry to the red Logs
+ * state with the broken step named.
  * @module dsh-plugin-local-infer/ui/routes/stop
  */
 import type { LocalInferService } from 'dsh-plugin-local-infer/service';
@@ -13,4 +16,4 @@ import type { LocalInferRoute } from '../route.ts';
  * step holds by an effect.
  */
 export declare function stopRoute(localInfer: LocalInferService): LocalInferRoute;
-//# sourceMappingURL=stop.d.ts.map
+//# sourceMappingURL=stop.d.ts.map

package/packages/ui/lib/routes/stop.js

@@ -1,9 +1,12 @@
 /**
  * The POST /local-infer/stop route: it renders the same plan the launch
  * rendered and runs the service's stop entry point, so the stop targets the
- * exact container or process the launch started. The stop then clears the
- * target entry's launch record, so a recycled pid cannot re-link an engine
- * the user just stopped.
+ * exact container or process the launch started (a re-adopted engine through
+ * the record's pid). The stop then clears the target entry's launch record,
+ * so a recycled pid cannot re-link an engine the user just stopped. A stop
+ * that fails persists a note to the last-run logs and the log file and
+ * answers 500, so the card's stop deadline settles the entry to the red Logs
+ * state with the broken step named.
  * @module dsh-plugin-local-infer/ui/routes/stop
  */
 import { stopEngine } from "../ops/engine.js";
@@ -26,4 +29,4 @@ export function stopRoute(localInfer) {
         },
     });
 }
-//# sourceMappingURL=stop.js.map
+//# sourceMappingURL=stop.js.map

package/packages/ui/lib/routes/stream.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The NDJSON stream helpers the get and launch routes share: the one-line
+ * writer, the throttled progress sink the routes hand the hf download's
+ * onChunk callback to, and the abort controller that watches the response
+ * for the card's Cancel. The helpers keep the two routes' stream wiring
+ * identical, so a change to the throttle cadence, the event line format, or
+ * the cancel rule lands in one place.
+ * @module dsh-plugin-local-infer/ui/routes/stream
+ */
+import type { HfProgress } from 'dsh-plugin-local-infer/core';
+import type { RouteResponder } from '../route.ts';
+export declare const PROGRESS_MIN_INTERVAL_MS = 500;
+/**
+ * ndjsonLine writes one NDJSON event line to the stream: the JSON-encoded
+ * event plus a newline, through the responder's chunk writer (a fake
+ * response without write() collects nothing).
+ */
+export declare function ndjsonLine(res: RouteResponder, line: unknown): void;
+/**
+ * throttledProgressSink builds the onChunk callback a stream route hands the
+ * hf download's progress sink to: the core chunk folder turns the tqdm lines
+ * into a structured state, and the sink emits the state at most once per
+ * PROGRESS_MIN_INTERVAL_MS, so a hot tqdm cadence never floods the stream.
+ * The first parseable state emits immediately (the last-emit timestamp
+ * starts at 0).
+ */
+export declare function throttledProgressSink(write: (progress: HfProgress) => void): (chunk: string) => void;
+/**
+ * abortOnResponseClose wires the card's cancel to the response: a client
+ * disconnect (the response's close before the route ends) aborts the
+ * returned controller, and markFinished settles the run so a close after
+ * the route ended reads as the normal end, not a cancel. A fake response
+ * without on() never fires the close, and the run degrades to running to
+ * completion.
+ */
+export declare function abortOnResponseClose(res: RouteResponder): {
+    signal: AbortSignal;
+    markFinished(): void;
+};
+//# sourceMappingURL=stream.d.ts.map

package/packages/ui/lib/routes/stream.js

@@ -0,0 +1,68 @@
+/**
+ * The NDJSON stream helpers the get and launch routes share: the one-line
+ * writer, the throttled progress sink the routes hand the hf download's
+ * onChunk callback to, and the abort controller that watches the response
+ * for the card's Cancel. The helpers keep the two routes' stream wiring
+ * identical, so a change to the throttle cadence, the event line format, or
+ * the cancel rule lands in one place.
+ * @module dsh-plugin-local-infer/ui/routes/stream
+ */
+import { foldHfProgressChunk } from '../../../core/lib/index.js';
+// The minimum interval between progress events: the tqdm cadence is hot (a
+// bar redraw per chunk), so a route emits at most one event per half second,
+// and the card's own throttle bounds the store updates.
+export const PROGRESS_MIN_INTERVAL_MS = 500;
+/**
+ * ndjsonLine writes one NDJSON event line to the stream: the JSON-encoded
+ * event plus a newline, through the responder's chunk writer (a fake
+ * response without write() collects nothing).
+ */
+export function ndjsonLine(res, line) {
+    res.write(JSON.stringify(line) + '\n');
+}
+/**
+ * throttledProgressSink builds the onChunk callback a stream route hands the
+ * hf download's progress sink to: the core chunk folder turns the tqdm lines
+ * into a structured state, and the sink emits the state at most once per
+ * PROGRESS_MIN_INTERVAL_MS, so a hot tqdm cadence never floods the stream.
+ * The first parseable state emits immediately (the last-emit timestamp
+ * starts at 0).
+ */
+export function throttledProgressSink(write) {
+    let folded;
+    let lastProgressAt = 0;
+    return (chunk) => {
+        const state = foldHfProgressChunk(chunk, folded);
+        if (state === undefined)
+            return;
+        folded = state;
+        const now = Date.now();
+        if (now - lastProgressAt >= PROGRESS_MIN_INTERVAL_MS) {
+            lastProgressAt = now;
+            write(state);
+        }
+    };
+}
+/**
+ * abortOnResponseClose wires the card's cancel to the response: a client
+ * disconnect (the response's close before the route ends) aborts the
+ * returned controller, and markFinished settles the run so a close after
+ * the route ended reads as the normal end, not a cancel. A fake response
+ * without on() never fires the close, and the run degrades to running to
+ * completion.
+ */
+export function abortOnResponseClose(res) {
+    const controller = new AbortController();
+    let finished = false;
+    res.onClose(() => {
+        if (!finished)
+            controller.abort();
+    });
+    return {
+        signal: controller.signal,
+        markFinished: () => {
+            finished = true;
+        },
+    };
+}
+//# sourceMappingURL=stream.js.map

package/packages/ui/lib/routes/summary.d.ts

@@ -12,4 +12,4 @@ import type { LocalInferRoute } from '../route.ts';
  * register step holds by an effect.
  */
 export declare function summaryRoute(localInfer: LocalInferService): LocalInferRoute;
-//# sourceMappingURL=summary.d.ts.map
+//# sourceMappingURL=summary.d.ts.map

package/packages/ui/lib/routes/summary.js

@@ -23,4 +23,4 @@ export function summaryRoute(localInfer) {
         },
     });
 }
-//# sourceMappingURL=summary.js.map
+//# sourceMappingURL=summary.js.map

package/packages/ui/lib/routes/unregister.d.ts

@@ -11,4 +11,4 @@ import type { LocalInferRoute } from '../route.ts';
  * the register step holds by an effect.
  */
 export declare function unregisterRoute(localInfer: LocalInferService): LocalInferRoute;
-//# sourceMappingURL=unregister.d.ts.map
+//# sourceMappingURL=unregister.d.ts.map

package/packages/ui/lib/routes/unregister.js

@@ -23,4 +23,4 @@ export function unregisterRoute(localInfer) {
         },
     });
 }
-//# sourceMappingURL=unregister.js.map
+//# sourceMappingURL=unregister.js.map

package/packages/ui/lib/viewmodels/deps.d.ts

@@ -1,31 +1 @@
-/**
- * The deps panel view model: the detected hardware (with its package
- * manager), the dep plan the service resolves, the per-dep statuses, the
- * copy/paste install string, and the Play/Run trust gate the stored config
- * carries. resolveBuildMode picks the deploy mode the plan prices, the same
- * value the docker-not-installed guideline reads, so the panel and the
- * warning never disagree about the mode.
- * @module dsh-plugin-local-infer/ui/viewmodels/deps
- */
-import type { Config } from 'dsh-plugin-local-infer/core';
-import type { BuildMode } from '../../../core/lib/index.js';
-import type { LocalInferService } from 'dsh-plugin-local-infer/service';
-import type { EngineInfo } from '../../../providers/lib/index.js';
-import type { DepsModel } from '../deps.ts';
-import type { DepsRequest } from '../request.ts';
-/**
- * resolveBuildMode picks the deploy mode the dep plan prices: the config's
- * buildMode when the selected engine supports it, else the engine's default
- * (local when the engine can build locally, docker when it cannot). The
- * docker-not-installed guideline reads this same value, so the panel and the
- * warning never disagree about the mode.
- */
-export declare function resolveBuildMode(engine: EngineInfo, config: Config): BuildMode;
-/**
- * buildDeps assembles the deps panel read model for one engine and config:
- * the detected hardware (with its package manager), the dep plan the service
- * resolves, the per-dep statuses, the copy/paste install string, and the
- * Play/Run trust gate the stored config carries.
- */
-export declare function buildDeps(localInfer: LocalInferService, request?: DepsRequest): Promise<DepsModel>;
-//# sourceMappingURL=deps.d.ts.map
+

package/packages/ui/lib/viewmodels/deps.js

@@ -1,89 +1 @@
-/**
- * The deps panel view model: the detected hardware (with its package
- * manager), the dep plan the service resolves, the per-dep statuses, the
- * copy/paste install string, and the Play/Run trust gate the stored config
- * carries. resolveBuildMode picks the deploy mode the plan prices, the same
- * value the docker-not-installed guideline reads, so the panel and the
- * warning never disagree about the mode.
- * @module dsh-plugin-local-infer/ui/viewmodels/deps
- */
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { CHAT_TEMPLATE_FILE, checkDeps, hfChatTemplateCommand, renderInstallString, } from '../../../core/lib/index.js';
-import { ENGINES } from '../../../providers/lib/index.js';
-import { readConfig } from "../config.js";
-import { renderDeps } from "../deps.js";
-import { isHfRepoReference } from "./summaryHelpers.js";
-/**
- * resolveBuildMode picks the deploy mode the dep plan prices: the config's
- * buildMode when the selected engine supports it, else the engine's default
- * (local when the engine can build locally, docker when it cannot). The
- * docker-not-installed guideline reads this same value, so the panel and the
- * warning never disagree about the mode.
- */
-export function resolveBuildMode(engine, config) {
-    // The default is the engine's easiest non-docker mode: the binary install
-    // when the engine ships one (the Strata one-line path), else the source
-    // build, else docker.
-    const defaultMode = engine.supports.binary === true
-        ? 'binary'
-        : engine.supports.local
-            ? 'local'
-            : 'docker';
-    const requested = typeof config.buildMode === 'string' ? config.buildMode : undefined;
-    if ((requested === 'docker' || requested === 'local' || requested === 'binary') &&
-        engine.supports[requested]) {
-        return requested;
-    }
-    return defaultMode;
-}
-/**
- * buildDeps assembles the deps panel read model for one engine and config:
- * the detected hardware (with its package manager), the dep plan the service
- * resolves, the per-dep statuses, the copy/paste install string, and the
- * Play/Run trust gate the stored config carries.
- */
-export async function buildDeps(localInfer, request) {
-    const stored = readConfig();
-    const engineId = request?.engine ?? stored.engine;
-    const config = request?.config ?? stored.config;
-    // ENGINES is a known non-empty constant, so the fallback is always defined.
-    const engine = ENGINES.find((entry) => entry.id === engineId) ?? ENGINES[0];
-    const buildMode = resolveBuildMode(engine, config);
-    const hardware = await localInfer.detectHardware();
-    const deps = await localInfer.deps(engine.id, buildMode, hardware);
-    const checks = await checkDeps(deps, hardware);
-    // The chat-template row: when a selected template is an HF repo reference
-    // and its file is not in the model directory, the System dependencies box
-    // shows the download command (the auto-download's fallback when the CLI is
-    // missing or the fetch failed). A present template, a local path, or no
-    // template leaves the row off.
-    const modelDirectory = localInfer.defaultModelDirectory();
-    const rawModelDir = config.modelDirectory;
-    const modelDir = typeof rawModelDir === 'string' && rawModelDir.trim() !== '' ? rawModelDir : modelDirectory;
-    const chatTemplateValue = typeof config.chatTemplate === 'string' ? config.chatTemplate : '';
-    let chatTemplate;
-    if (isHfRepoReference(chatTemplateValue) && !existsSync(join(modelDir, CHAT_TEMPLATE_FILE))) {
-        chatTemplate = {
-            repo: chatTemplateValue,
-            present: false,
-            hfCli: (await localInfer.hfCliAvailable()) !== null,
-            downloadCommand: hfChatTemplateCommand(chatTemplateValue, modelDir),
-        };
-    }
-    // exactOptionalPropertyTypes: the chat-template row only lands while a
-    // selected template is missing, so the key is included conditionally.
-    const depsInput = {
-        engineId: engine.id,
-        buildMode,
-        packageManager: hardware.packageManager ?? null,
-        checks,
-        installString: renderInstallString(deps, hardware),
-        runAllowed: stored.allowRunDeps,
-    };
-    if (chatTemplate !== undefined) {
-        depsInput.chatTemplate = chatTemplate;
-    }
-    return renderDeps(depsInput);
-}
-//# sourceMappingURL=deps.js.map
+

package/packages/ui/lib/viewmodels/depsHelpers.d.ts

@@ -1,28 +1 @@
-/**
- * The Play/Run helper for the deps panel: runInstallFor refuses with a 409
- * while the trust gate is off (the copy/paste path is always the fallback),
- * runs the install through the service, and refreshes the deps model from the
- * re-check, so the "Get" gate opens only after a re-check passes.
- * @module dsh-plugin-local-infer/ui/viewmodels/depsHelpers
- */
-import type { InstallResult } from 'dsh-plugin-local-infer/core';
-import type { LocalInferService } from 'dsh-plugin-local-infer/service';
-import type { DepsModel } from '../deps.ts';
-import type { DepsRequest } from '../request.ts';
-/**
- * InstallResponse is the answer to a Play/Run: the install result and the
- * refreshed deps model, so the card re-renders the gate from the same
- * re-check the install ran.
- */
-export interface InstallResponse {
-    result: InstallResult;
-    deps: DepsModel;
-}
-/**
- * runInstallFor is the Play/Run path: it refuses with a 409 while the
- * trust gate is off (the copy/paste path is always the fallback), runs the
- * install through the service, and refreshes the deps model from the
- * re-check, so the "Get" gate opens only after a re-check passes.
- */
-export declare function runInstallFor(localInfer: LocalInferService, request: DepsRequest): Promise<InstallResponse>;
-//# sourceMappingURL=depsHelpers.d.ts.map
+