dsh-plugin-local-infer 0.1.0 → 0.1.2

package/packages/ui/lib/meter.js

@@ -6,7 +6,7 @@
  * as authoritative. The model is pure data, so the panel (Phase 8) renders
  * it without touching the domain model, and the mapping stays unit-testable
  * here.
- * @module @dsh/dsh-plugin-local-infer/ui/meter
+ * @module dsh-plugin-local-infer/ui/meter
  */
 /**
  * renderMeter builds the render model for a VRAM estimate. The segments are

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

@@ -12,11 +12,11 @@
  * ~/.dsh/local-infer/config.json, shared with the CLI, so the browser never
  * sees a secret it did not store. The routes are held by an effect, so they
  * go when the plugin does.
- * @module @dsh/dsh-plugin-local-infer/ui/route
+ * @module dsh-plugin-local-infer/ui/route
  */
 import type { Context } from '@deepseek-ai/cordis';
-import type { Config, DefaultProvenance, HardwareProfile, InstallResult, ProviderLaunchRecord, ProviderStatus, RegisterResult, VramModel, VramVerdict } from '@dsh/dsh-plugin-local-infer/core';
-import type { DownloadResult, LaunchResult, LocalInferService } from '@dsh/dsh-plugin-local-infer/service';
+import type { Config, DefaultProvenance, HardwareProfile, InstallResult, LaunchStep, LifecycleHost, ProviderLaunchRecord, ProviderStatus, RegisterResult, VramModel, VramVerdict } from 'dsh-plugin-local-infer/core';
+import type { DownloadResult, EngineDeathEvent, LaunchResult, LocalInferService } from 'dsh-plugin-local-infer/service';
 import type { EngineInfo } from '../../providers/lib/index.js';
 import type { DepsModel } from './deps.ts';
 import type { FormModel } from './form.ts';
@@ -41,6 +41,13 @@ interface IncomingLike extends AsyncIterable<Buffer> {
 }
 interface OutgoingLike {
     writeHead(status: number, headers?: Record<string, string>): OutgoingLike;
+    /**
+     * Optional: stream one chunk of the answer, used by the Get route to
+     * append build output to the card's Logs section while it runs. The web
+     * server hands the handler a node ServerResponse; the tests' fake may
+     * omit it, and the route degrades to collecting only.
+     */
+    write?(chunk: string): unknown;
     end(body?: string): void;
 }
 /**
@@ -59,6 +66,8 @@ export interface LocalInferSummary {
             docker: boolean;
             local: boolean;
         };
+        defaultBuildCommand?: string;
+        defaultDockerTag?: string;
     }[];
     models: {
         id: string;
@@ -165,6 +174,8 @@ export declare function localInferConfigPath(): string;
 export interface StoredPlatformConfig {
     engineDirectory?: string;
     engineFork?: string;
+    buildCommands?: string;
+    dockerTag?: string;
 }
 /**
  * StoredProviderConfig is one saved provider model+engine config the card
@@ -205,6 +216,18 @@ export declare function readConfig(): StoredConfig;
  * configs, and the help toggle, creating the directory tree on first write.
  */
 export declare function writeConfig(engine: string, config: Config, allowRunDeps: boolean, platform?: Record<string, StoredPlatformConfig>, showHelp?: boolean, providers?: StoredProviderConfig[], logPath?: string, lastLogs?: string): void;
+/**
+ * relinkStoredProviders prices every stored provider launch record against the
+ * live process table through the service's re-link rule and returns the
+ * provider list the card should read: an adopted engine is re-marked plugin-
+ * launched and tied to its model by the service, and a liveness watcher starts
+ * on its port so a later pkill settles the stored state through the death
+ * observer without another summary read; a dead engine's record is cleared on
+ * disk here (the previous-pid list with it), so a recycled pid cannot re-link
+ * to a config whose engine is down. The route calls it on mount and the
+ * summary calls it per read, making re-attach independent of the card opening.
+ */
+export declare function relinkStoredProviders(localInfer: LocalInferService, stored: StoredConfig): Promise<StoredProviderConfig[]>;
 /**
  * buildSummary assembles the card's read model for one engine and config: the
  * static engine and model lists, the detected hardware, the form model the
@@ -311,25 +334,44 @@ export declare function chatTemplateDownloadFor(localInfer: LocalInferService, r
  * unsaved Engine Directory / Engine Fork edits for the engine, so a launch uses
  * them without a prior save. `providerId` names the saved provider entry the
  * launch drives, so the route persists the launch record (or clears it on a
- * stop) on that entry. Absent values fall back to the stored config, the
- * same rule the summary route applies.
+ * stop) on that entry. `autoRebuild` is the card's "Auto Rebuild" checkbox:
+ * when false, the deploy step skips the git sync (fetch, rebase, rebuild) and
+ * launches the checkout as-is. Absent values fall back to the stored config,
+ * the same rule the summary route applies.
  */
 export interface LaunchRequest {
     engine?: string;
     config?: Config;
     platform?: StoredPlatformConfig;
     providerId?: string;
+    autoRebuild?: boolean;
 }
 /**
  * launchEngine renders the plan the registered adapter produces for the config
  * and the detected hardware, then runs the service's launch entry point
  * (deploy, then the health poll). The detail the launch returns names the
- * broken step when the engine does not come up. The launch step persists the
+ * broken step when the engine does not come up. The launch line (the engine
+ * binary and its arguments) leads the run logs the card's Logs section and
+ * the log file carry, so a broken setup diagnoses against the exact child
+ * process the launch started. The launch step persists the
  * launch record (the engine pid, start time, launch arguments, and the DSH
  * process pid that launched it) on the request's provider entry, so a DSH
  * restart can re-link a surviving engine to its config.
  */
-export declare function launchEngine(localInfer: LocalInferService, request: LaunchRequest): Promise<LaunchResult>;
+export declare function launchEngine(localInfer: LocalInferService, request: LaunchRequest, onProgress?: (step: LaunchStep) => void): Promise<LaunchResult>;
+/**
+ * handleEngineDeath persists a provider entry's state when its engine process
+ * dies outside the plugin's stop path: a crash, a pkill of a plugin-launched
+ * child seen through the service's exit watch, or the poll-detected exit of a
+ * process adopted after a DSH restart. The entry whose launch record names the
+ * dead pid (or the dead engine-and-port, when the report carries no pid match)
+ * has its record cleared, so a restart never re-links a dead pid, and the exit
+ * line lands in the card's last-run logs beside the engine's own output. An
+ * event that matches no entry carrying a record (a stop the route already
+ * cleared, an engine the plugin never tracked) is a no-op, which keeps an
+ * expected stop quiet.
+ */
+export declare function handleEngineDeath(event: EngineDeathEvent): void;
 /**
  * persistLaunchLogs stores a launch's captured output as the last run and
  * writes it to the configured log file. The log file is only written when the
@@ -346,6 +388,32 @@ export declare function persistLaunchLogs(result: LaunchResult, engineId: string
  * user just stopped.
  */
 export declare function stopEngine(localInfer: LocalInferService, request: LaunchRequest): Promise<void>;
+/**
+ * GetRequest is the query the card sends for the Get route: the engine and
+ * the config the dep plan and the build mode read from, and the platform
+ * override (the card's unsaved Engine Directory / Engine Fork edits), the
+ * same rule the launch request applies. Absent values fall back to the
+ * stored config.
+ */
+export interface GetRequest {
+    engine?: string;
+    config?: Config;
+    platform?: StoredPlatformConfig;
+}
+/**
+ * getEngine is the Get step: it syncs the engine checkout (clone the git
+ * repo, or the fork when the platform entry provides one; fetch and rebase
+ * a clean checkout; abort with a Logs alert when the checkout has local
+ * changes), runs the system dependency plan, and runs the engine's build
+ * steps. Every command and its output streams through log as it lands, so
+ * the card appends it to the Logs section live. The dependency install only
+ * runs while the Play/Run trust gate is on; with the gate off the deps are
+ * re-checked and a missing one aborts the step with the copy/paste note.
+ */
+export declare function getEngine(localInfer: LocalInferService, request: GetRequest, log: (chunk: string) => void, host?: LifecycleHost): Promise<{
+    ok: boolean;
+    detail?: string;
+}>;
 /**
  * RegisterRequest is the query the card sends for the register and
  * unregister routes: the engine and the config the plan renders from, and
@@ -393,14 +461,17 @@ export declare function unregisterFor(localInfer: LocalInferService, request?: R
     removed: boolean;
 }>;
 /**
- * registerLocalInferRoute registers the summary, save, deps, install, launch,
- * stop, register, and unregister routes on the web server and holds them by
- * an effect, so a bundle switch off removes them before the next switch on
- * re-registers. The scoped context carries the webServer; the localInfer
- * service is passed in because the scope only injects what it names.
+ * registerLocalInferRoute registers the summary, save, deps, install, get,
+ * launch, stop, register, and unregister routes on the web server and holds
+ * them by an effect, so a bundle switch off removes them before the next
+ * switch on re-registers. The scoped context carries the webServer; the
+ * localInfer service is passed in because the scope only injects what it
+ * names. The optional getHost is the lifecycle host the Get route's git and
+ * build steps run through; it defaults to the node host, and a test injects
+ * a stub so the route never clones a real repo in CI.
  */
 export declare function registerLocalInferRoute(scope: Context & {
     webServer: WebServerService;
-}, localInfer: LocalInferService): void;
+}, localInfer: LocalInferService, getHost?: LifecycleHost): void;
 export {};
 //# sourceMappingURL=route.d.ts.map