dsh-plugin-local-infer 0.1.1 → 0.1.2

package/dsh/client.js

@@ -83,6 +83,8 @@ window.__ModuleLoader__.load({
         run: 'Run',
         running: 'running...',
         get: 'Get',
+        getting: 'getting...',
+        getFailed: 'get failed',
         allowRun: 'Allow one-click install (sudo)',
         depsSatisfied: 'All dependencies satisfied.',
         installRejected: 'one-click install is not allowed; copy the install string instead',
@@ -94,6 +96,7 @@ window.__ModuleLoader__.load({
         unregistered: 'removed',
         unregisterFailed: 'remove failed',
         launch: 'Launch',
+        autoRebuild: 'Auto Rebuild',
         launching: 'Launching...',
         launchFailed: 'launch failed',
         runningOn: 'running on port',
@@ -106,6 +109,8 @@ window.__ModuleLoader__.load({
         enginePlatform: 'Engine platform',
         engineDirectory: 'Engine Directory',
         engineFork: 'Engine Fork (Git Repo)',
+        buildCommands: 'Build commands',
+        dockerTag: 'Docker tag',
         dirPlaceholder: 'directory path',
         forkPlaceholder: 'git repo url',
         hfCliDetected: 'HF CLI detected:',
@@ -115,6 +120,7 @@ window.__ModuleLoader__.load({
         downloaded: 'download complete',
         downloadFailed: 'download failed',
         helpToggle: 'Show or hide field help',
+        refresh: 'Re-fetch the card data from the host',
         engineHelp:
           'Inference engines have different strengths and weaknesses for specific models and hardware.',
         modelHelp:
@@ -123,8 +129,12 @@ window.__ModuleLoader__.load({
           'How the engine is deployed. local builds it from source on the host; docker pulls a prebuilt image. The dependency plan and hardware guidelines price the selected mode.',
         modelDirHelp: 'Where model files are downloaded and served from.',
         engineDirHelp:
-          'Local directory of the engine source. In local build mode the deploy step clones and builds the engine here.',
+          'Local directory of the engine source. Get clones or updates the git repo and builds the engine here; with no override it lands in the model directory under the engine name.',
         engineForkHelp: 'Git repo that overrides the engine default upstream for the clone step.',
+        buildCommandsHelp:
+          'Local build command that overrides the engine default for the checkout build. Shown only in local build mode.',
+        dockerTagHelp:
+          'Docker image tag the docker deploy pulls. Shown only in docker build mode.',
         providers: 'Providers',
         newProvider: 'New provider',
         edit: 'Edit',
@@ -142,6 +152,10 @@ window.__ModuleLoader__.load({
         entryLaunch: 'Launch',
         entryStop: 'Stop',
         entryLogs: 'Logs',
+        entryPrereqs: 'Prereqs...',
+        entryDownloading: 'Downloading...',
+        entryBuilding: 'Building...',
+        entryLaunching: 'Launching...',
         chatTemplatePreset: 'Chat template preset',
         customChatTemplate: 'Custom Chat template',
         custom: 'Custom',
@@ -210,6 +224,8 @@ window.__ModuleLoader__.load({
         run: '运行',
         running: '运行中…',
         get: '获取',
+        getting: '获取中…',
+        getFailed: '获取失败',
         allowRun: '允许一键安装 (sudo)',
         depsSatisfied: '所有依赖已满足。',
         installRejected: '未允许一键安装；请复制安装命令。',
@@ -221,6 +237,7 @@ window.__ModuleLoader__.load({
         unregistered: '已移除',
         unregisterFailed: '移除失败',
         launch: '启动',
+        autoRebuild: '自动重建',
         launching: '启动中…',
         launchFailed: '启动失败',
         runningOn: '运行于端口',
@@ -233,6 +250,8 @@ window.__ModuleLoader__.load({
         enginePlatform: '引擎平台',
         engineDirectory: '引擎目录',
         engineFork: '引擎 Fork (Git 仓库)',
+        buildCommands: '构建命令',
+        dockerTag: 'Docker 标签',
         dirPlaceholder: '目录路径',
         forkPlaceholder: 'git 仓库地址',
         hfCliDetected: '检测到 HF CLI:',
@@ -242,13 +261,16 @@ window.__ModuleLoader__.load({
         downloaded: '下载完成',
         downloadFailed: '下载失败',
         helpToggle: '显示或隐藏字段帮助',
+        refresh: '从主机重新加载卡片数据',
         engineHelp: '推理引擎针对特定模型和硬件各有优劣。',
         modelHelp: '引擎服务的模型。可选项包括引擎默认模型和模型目录中已有的模型文件。',
         buildHelp:
           '引擎的部署方式。local 在主机上从源码构建；docker 拉取预构建镜像。依赖计划和硬件准则按所选模式计价。',
         modelDirHelp: '模型文件的下载和服务目录。',
-        engineDirHelp: '引擎源码的本地目录。本地构建模式下，部署步骤在此克隆并构建引擎。',
+        engineDirHelp: '引擎源码的本地目录。“获取”会在此克隆或更新 git 仓库并构建引擎；未覆盖时，仓库落在模型目录下以引擎命名的子目录中。',
         engineForkHelp: '用于克隆步骤、覆盖引擎默认上游的 git 仓库。',
+        buildCommandsHelp: '本地构建命令，覆盖引擎默认的检查构建。仅在本地构建模式下显示。',
+        dockerTagHelp: 'docker 部署拉取的镜像标签。仅在 docker 构建模式下显示。',
         providers: '提供方',
         newProvider: '新增提供方',
         edit: '编辑',
@@ -265,6 +287,10 @@ window.__ModuleLoader__.load({
         entryLaunch: '启动',
         entryStop: '停止',
         entryLogs: '日志',
+        entryPrereqs: '前置条件…',
+        entryDownloading: '下载中…',
+        entryBuilding: '构建中…',
+        entryLaunching: '启动中…',
         chatTemplatePreset: '聊天模板预设',
         customChatTemplate: '自定义聊天模板',
         custom: '自定义',
@@ -432,6 +458,61 @@ window.__ModuleLoader__.load({
       color: '#fff',
       border: 'none',
     });
+
+    // The per-entry launch state machine: the card's Launch control lifecycle.
+    // The states are the button's reads: idle (a plain Launch), the four
+    // rebuild phases (prereqs, download, build, launch), running (a Stop), and
+    // failed (a red Logs). launchNextState is the hardened transition: a step
+    // event only advances forward through the rebuild phases (a stale or
+    // out-of-order step is a no-op), a healthy result settles to running, a
+    // failed result settles to failed, and a stop or a break (the Logs control,
+    // a navigation away) resets to idle. An event that names no legal next
+    // state leaves the control where it is, so a late event never corrupts it.
+    var LAUNCH_STEP_ORDER = { prereqs: 0, download: 1, build: 2, launch: 3 };
+    var LAUNCH_PHASE_STATES = ['prereqs', 'download', 'build', 'launch'];
+    // The health-poll deadline: the route's poll runs up to two minutes, so a
+    // client-side deadline just past that cap forces a hung launch to the red
+    // Logs state. It arms only for the launch phase; the rebuild phases
+    // (prereqs, download, build) run as long as they need to, so a slow build
+    // never reads as a failure.
+    var LAUNCH_HEALTH_DEADLINE_MS = 150000;
+
+    function launchIsPhase(state) {
+      return LAUNCH_PHASE_STATES.indexOf(state) !== -1;
+    }
+
+    function launchNextState(current, event) {
+      var type = event.type;
+      if (type === 'start') {
+        // A launch begins from idle (a plain Launch) or failed (a re-launch
+        // after the Logs control cleared the failed state).
+        return current === 'idle' || current === 'failed' ? 'prereqs' : current;
+      }
+      if (type === 'step') {
+        var target = event.step;
+        if (LAUNCH_STEP_ORDER[target] === undefined) return current;
+        if (current === 'idle' || current === 'failed') return target;
+        if (current === 'running') return current;
+        var currentOrder = LAUNCH_STEP_ORDER[current];
+        if (currentOrder === undefined) return current;
+        return LAUNCH_STEP_ORDER[target] >= currentOrder ? target : current;
+      }
+      if (type === 'healthy') {
+        return launchIsPhase(current) ? 'running' : current;
+      }
+      if (type === 'failed') {
+        return launchIsPhase(current) ? 'failed' : current;
+      }
+      if (type === 'stop') {
+        // A stop settles a running engine (or a launch in flight) back to idle.
+        return current === 'running' || launchIsPhase(current) ? 'idle' : current;
+      }
+      if (type === 'reset') {
+        return 'idle';
+      }
+      return current;
+    }
+
     // The deps panel. The install block is a copy/paste target, so it gets a
     // monospace pre with its own copy button; the dep rows read their status
     // from a state dot (the DSH StateDot, or its glyph fallback), not a word,
@@ -476,10 +557,10 @@ window.__ModuleLoader__.load({
       gap: 4,
       justifyContent: 'flex-end',
     };
-    // The circular "?" button in the card header. It toggles the per-field
-    // descriptions; the preference persists through the save route, so it
-    // survives a reload. The active state reads as the accent fill; the
-    // inactive state as the muted outline.
+    // The circular header buttons: the "?" help toggle and the refresh
+    // action. The active state reads as the accent fill; the inactive state
+    // as the muted outline. The help preference persists through the save
+    // route, so it survives a reload.
     var HELP_BUTTON_STYLE = (active) => ({
       width: 20,
       height: 20,
@@ -818,13 +899,24 @@ window.__ModuleLoader__.load({
     // a collapsed card with a status dot (green running, red stopped, yellow
     // The per-entry Launch control: a card entry's own lifecycle button, shown
     // alongside its Edit and Delete controls. Idle reads as a Launch button
-    // that starts the entry's engine; a launch in flight shows a disabled
-    // control with the spinner inside; a healthy engine reads as an enabled
-    // Stop; a launch that timed out reads as a red Logs control that opens the
-    // entry for editing, the same action as Edit.
+    // that starts the entry's engine; a rebuild in flight shows a disabled
+    // control with the spinner and the phase label (Prereqs, Downloading,
+    // Building, Launching); a healthy engine reads as an enabled Stop; a launch
+    // that timed out reads as a red Logs control that opens the entry for
+    // editing, the same action as Edit.
     function renderEntryLaunchButton(react, primitives, provider, opts) {
       var state = (opts.launchState || {})[provider.id];
-      if (state !== undefined && state.status === 'launching') {
+      var status = state !== undefined ? state.status : 'idle';
+      // A rebuild phase in flight: a disabled control with the spinner and the
+      // phase label, so the button reads the step that is actually running.
+      var phaseLabels = {
+        prereqs: opts.prereqsLabel,
+        download: opts.downloadingLabel,
+        build: opts.buildingLabel,
+        launch: opts.launchingLabel,
+      };
+      var phaseLabel = phaseLabels[status];
+      if (phaseLabel !== undefined) {
         return react.createElement(
           'button',
           {
@@ -834,20 +926,17 @@ window.__ModuleLoader__.load({
               { display: 'inline-flex', alignItems: 'center', gap: 4, opacity: 0.7 },
               GHOST_BUTTON,
             ),
-            'aria-label': opts.launchingLabel,
+            'aria-label': phaseLabel,
           },
           renderThrobber(react, primitives),
-          react.createElement('span', null, opts.launchingLabel),
+          react.createElement('span', null, phaseLabel),
         );
       }
       // The Stop control reads from the provider status dot, not just the
       // per-entry launch state: the launch state is lost when the user
       // navigates away from the plugin page and back, so a running engine
       // (a green dot) must keep the control as Stop, not reset to Launch.
-      if (
-        (state !== undefined && state.status === 'running') ||
-        provider.status === 'running'
-      ) {
+      if (status === 'running' || provider.status === 'running') {
         return renderButton(
           react,
           primitives,
@@ -856,10 +945,10 @@ window.__ModuleLoader__.load({
           opts.stopLabel,
         );
       }
-      if (state !== undefined && state.status === 'failed') {
-        // A launch that timed out: a red Logs control that opens the entry for
-        // editing and clears the failed state, so the control reads as Launch
-        // again and the user can fix the config and re-launch.
+      if (status === 'failed') {
+        // A launch that timed out or failed: a red Logs control that opens the
+        // entry for editing and clears the failed state, so the control reads
+        // as Launch again and the user can fix the config and re-launch.
         return react.createElement(
           'button',
           {
@@ -1568,6 +1657,11 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // The Get run's output-idle cap. Two minutes without a streamed line
+    // reads as a stalled build: the card re-enables Launch while the run
+    // keeps streaming in the background.
+    var GET_IDLE_MS = 120000;
+
     // The "System dependencies" panel: the per-dep status list, the copy/paste
     // install block, the Play/Run arrow (only while the trust gate is on),
     // and the "Get" gate that stays disabled until every dep reports
@@ -1696,8 +1790,11 @@ window.__ModuleLoader__.load({
             react,
             primitives,
             'primary',
-            { onClick: actions.onGet, disabled: !deps.allSatisfied },
-            t.get,
+            {
+              onClick: actions.onGet,
+              disabled: !deps.allSatisfied || actions.getting === true,
+            },
+            actions.getting === true ? t.getting : t.get,
           ),
         ),
         actions.depsNote
@@ -1766,12 +1863,26 @@ window.__ModuleLoader__.load({
         // does.
         var launchingState = react.useState(false);
         var stoppingState = react.useState(false);
+        // The Get step's state. Get runs the git sync, the dependency plan,
+        // and the engine build on the host through /local-infer/get, and the
+        // streamed output lands in getLogs (the Logs section shows it while
+        // the run is in flight). Launch stays disabled while a Get is in
+        // flight; the idle timer re-enables it once GET_IDLE_MS passes with
+        // no output, so a silent build never parks the button.
+        var gettingState = react.useState(false);
+        var getLogsState = react.useState(null);
+        var getIdleTimerRef = react.useRef(null);
         // Whether the draft's engine is confirmed running, so the single
         // Launch/Stop control reads as Stop while the engine is up and Launch
         // while it is down, the same toggle the per-entry control does. A
         // healthy launch sets it, a stop clears it.
         var draftRunningState = react.useState(false);
         var lifecycleNoteState = react.useState('');
+        // The Auto Rebuild checkbox next to the form's Launch button. Checked
+        // by default: a launch runs the git sync (fetch, rebase, rebuild)
+        // before spawning the engine. Unchecked, the launch skips the sync and
+        // starts the checkout as-is.
+        var autoRebuildState = react.useState(true);
         // The model download state. The Download button runs the hf CLI
         // download through the /local-infer/download route, and the note
         // reports the answer the route returned.
@@ -1816,8 +1927,9 @@ window.__ModuleLoader__.load({
         // from the summary's stored template on load; a Save persists it.
         var logPathState = react.useState('');
         // The per-entry launch state: a map from provider id to the entry's
-        // lifecycle ('launching', 'running', 'failed') and the start time a
-        // launch began, so a card entry can show its spinner, Stop, or red
+        // launch-state-machine state (the rebuild phases 'prereqs', 'download',
+        // 'build', 'launch', plus 'running' and 'failed') and the start time a
+        // launch began, so a card entry can show its phase label, Stop, or red
         // Logs control. Absent entries read as idle (a plain Launch button).
         var entryLaunchState = react.useState({});
         var data = dataState[0];
@@ -1834,8 +1946,11 @@ window.__ModuleLoader__.load({
         var agentDefault = agentDefaultState[0];
         var launching = launchingState[0];
         var stopping = stoppingState[0];
+        var getting = gettingState[0];
+        var getLogs = getLogsState[0];
         var draftRunning = draftRunningState[0];
         var lifecycleNote = lifecycleNoteState[0];
+        var autoRebuild = autoRebuildState[0];
         var downloading = downloadingState[0];
         var downloadNote = downloadNoteState[0];
         var templateDownloading = templateDownloadingState[0];
@@ -1856,6 +1971,14 @@ window.__ModuleLoader__.load({
             ? 'new'
             : providerFormMode;
         var timerRef = react.useRef(null);
+        // The latest committed draft, mirrored into a ref so the debounced
+        // re-price reads the value the user last typed, not a stale closure.
+        // The effect runs after each render, so the ref settles before the
+        // 300ms timer fires.
+        var draftRef = react.useRef(null);
+        react.useEffect(() => {
+          draftRef.current = draft;
+        }, [draft]);
 
         var fetchSummary = react.useCallback(
           (engine, config) => {
@@ -1874,6 +1997,10 @@ window.__ModuleLoader__.load({
               )
               .then((next) => {
                 dataState[1](next);
+                // The streamed Get buffer yields to the persisted last-run
+                // logs the summary now carries, so the Logs section keeps
+                // the run's tail without a second copy.
+                getLogsState[1](null);
                 draftState[1]((current) => {
                   // The summary's platformConfigs is the host-persisted
                   // platform state, while the draft's platform entries are
@@ -1945,6 +2072,25 @@ window.__ModuleLoader__.load({
           [],
         );
 
+        // scheduleReprice resets the re-price timeout on every field change
+        // and fetches the summary (the VRAM Est. meter) and the deps panel
+        // only after typing pauses, so a fast keystroke stream is one round
+        // trip, not one per letter. The ref reads the latest committed draft,
+        // so the fetch prices the value the user last typed.
+        var scheduleReprice = react.useCallback(() => {
+          if (timerRef.current) {
+            clearTimeout(timerRef.current);
+          }
+          timerRef.current = setTimeout(() => {
+            var latest = draftRef.current;
+            if (latest === null || latest === undefined) {
+              return;
+            }
+            fetchSummary(latest.engine, latest.config);
+            fetchDeps(latest.engine, latest.config);
+          }, 300);
+        }, [fetchSummary, fetchDeps]);
+
         var load = react.useCallback(() => {
           fetchSummary(null, null);
           fetchDeps(null, null);
@@ -1956,9 +2102,11 @@ window.__ModuleLoader__.load({
           }
         }, [data, draft, load]);
 
-        // A field edit updates the draft config and re-prices the meter and
-        // form gating. Debounced so a slider drag is one round trip, not one
-        // per tick.
+        // A field edit updates the draft config and schedules a debounced
+        // re-price of the meter and form gating. The draft update is pure;
+        // the re-price (the VRAM Est. visualization) runs only after typing
+        // pauses, so a fast keystroke stream is one round trip, not one per
+        // letter.
         var onValue = react.useCallback(
           (key, value) => {
             noteState[1]('');
@@ -1968,22 +2116,15 @@ window.__ModuleLoader__.load({
             draftState[1]((current) => {
               var config = Object.assign({}, current.config);
               config[key] = value;
-              var next = {
+              return {
                 engine: current.engine,
                 config: config,
                 platform: current.platform || {},
               };
-              if (timerRef.current) {
-                clearTimeout(timerRef.current);
-              }
-              timerRef.current = setTimeout(() => {
-                fetchSummary(next.engine, next.config);
-                fetchDeps(next.engine, next.config);
-              }, 300);
-              return next;
             });
+            scheduleReprice();
           },
-          [fetchSummary, fetchDeps],
+          [scheduleReprice],
         );
 
         // The Model Directory field edit. A valid directory (non-blank, no
@@ -2141,7 +2282,9 @@ window.__ModuleLoader__.load({
         // The help toggle: flip the local state and persist the preference
         // through the save route, so it survives a reload. The save response
         // carries the fresh summary, so the data and the draft resync from
-        // the same round trip, the way the allow-run toggle does.
+        // the same round trip, the way the allow-run toggle does. The
+        // settings-only flag keeps the route from upserting a provider entry,
+        // so a toggle never mints a duplicate at the top of the list.
         var onToggleHelp = react.useCallback(
           (next) => {
             if (draft === null) {
@@ -2157,6 +2300,7 @@ window.__ModuleLoader__.load({
                 allowRunDeps: deps !== null && deps.runAllowed === true,
                 platform: draft.platform || {},
                 showHelp: next,
+                settingsOnly: true,
               }),
             })
               .then((response) =>
@@ -2265,18 +2409,11 @@ window.__ModuleLoader__.load({
             draftState[1]((_current) => {
               // The platform config is per-engine, so an engine switch keeps
               // the map and only resets the per-engine parameter config.
-              var next = { engine: engine, config: {}, platform: _current.platform || {} };
-              if (timerRef.current) {
-                clearTimeout(timerRef.current);
-              }
-              timerRef.current = setTimeout(() => {
-                fetchSummary(next.engine, next.config);
-                fetchDeps(next.engine, next.config);
-              }, 300);
-              return next;
+              return { engine: engine, config: {}, platform: _current.platform || {} };
             });
+            scheduleReprice();
           },
-          [fetchSummary, fetchDeps],
+          [scheduleReprice],
         );
 
         var save = react.useCallback(() => {
@@ -2492,6 +2629,9 @@ window.__ModuleLoader__.load({
           }
         }, [deps, t]);
 
+        // The allow-run toggle persists the trust gate through the save route.
+        // The settings-only flag keeps the route from upserting a provider
+        // entry, so a toggle never mints a duplicate at the top of the list.
         var onAllowRun = react.useCallback(
           (checked) => {
             if (draft === null) {
@@ -2506,6 +2646,7 @@ window.__ModuleLoader__.load({
                 allowRunDeps: checked,
                 platform: draft.platform || {},
                 showHelp: help,
+                settingsOnly: true,
               }),
             })
               .then((response) =>
@@ -2572,14 +2713,78 @@ window.__ModuleLoader__.load({
         }, [deps, draft, installing, t]);
 
         var onGet = react.useCallback(() => {
-          if (deps === null || draft === null) {
+          if (deps === null || draft === null || getting) {
             return;
           }
-          // "Get" is the gate: it re-checks the live dep state, so the button
-          // opens only after a re-check passes.
-          fetchDeps(draft.engine, draft.config);
-          depsNoteState[1](t.depsSatisfied);
-        }, [deps, draft, t, fetchDeps]);
+          // "Get" runs the git sync, the dependency plan, and the build on
+          // the host through /local-infer/get. The route streams its output;
+          // each chunk appends to the Logs section and re-arms the idle
+          // timer, and Launch stays disabled until the run finishes, fails,
+          // or falls silent for GET_IDLE_MS.
+          gettingState[1](true);
+          depsNoteState[1]('');
+          getLogsState[1]((data && data.lastLogs) || '');
+          var append = (text) => {
+            getLogsState[1]((current) => (current === null ? '' : current) + text);
+          };
+          var armIdle = () => {
+            if (getIdleTimerRef.current) {
+              clearTimeout(getIdleTimerRef.current);
+            }
+            // Two minutes without a line reads as a stalled build: release
+            // Launch while the run keeps streaming in the background.
+            getIdleTimerRef.current = setTimeout(() => {
+              gettingState[1](false);
+            }, GET_IDLE_MS);
+          };
+          armIdle();
+          var platform = (draft.platform || {})[draft.engine];
+          fetch('/local-infer/get', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+              engine: draft.engine,
+              config: draft.config,
+              platform: platform,
+            }),
+          })
+            .then((response) => {
+              if (!response.ok) {
+                return response.text().then((text) => {
+                  throw new Error(text || 'HTTP ' + response.status);
+                });
+              }
+              if (!response.body || typeof response.body.getReader !== 'function') {
+                // A host whose response cannot stream: read the whole body.
+                return response.text().then((text) => append(text));
+              }
+              var reader = response.body.getReader();
+              var decoder = new TextDecoder();
+              var pump = () =>
+                reader.read().then(({ done, value }) => {
+                  if (done) {
+                    return undefined;
+                  }
+                  append(decoder.decode(value, { stream: true }));
+                  armIdle();
+                  return pump();
+                });
+              return pump();
+            })
+            .catch((error) => {
+              append('\n' + t.getFailed + ': ' + (error && error.message ? error.message : '') + '\n');
+            })
+            .then(() => {
+              if (getIdleTimerRef.current) {
+                clearTimeout(getIdleTimerRef.current);
+                getIdleTimerRef.current = null;
+              }
+              gettingState[1](false);
+              // The route persisted the run as the last logs; the summary
+              // re-read hands the Logs section back to the stored value.
+              fetchSummary(draft.engine, draft.config);
+            });
+        }, [deps, draft, getting, data, t, fetchSummary]);
 
         var onRegister = react.useCallback(() => {
           if (draft === null || registering) {
@@ -2678,6 +2883,10 @@ window.__ModuleLoader__.load({
             engine: draft.engine,
             config: draft.config,
             platform: platform,
+            // The Auto Rebuild checkbox: false skips the git sync (fetch,
+            // rebase, rebuild) and launches the checkout as-is. The stop
+            // route ignores the key.
+            autoRebuild: autoRebuild,
           };
           // The provider entry the draft edits: the route persists the launch
           // record (and the stop's clear) on that entry, so a restart re-links
@@ -2699,9 +2908,48 @@ window.__ModuleLoader__.load({
             headers: { 'content-type': 'application/json' },
             body: launchBody(),
           })
-            .then((response) => response.json().then((body) => ({ ok: response.ok, body: body })))
-            .then(({ ok, body }) => {
-              if (ok) {
+            // The launch route streams NDJSON (a step event per phase, then a
+            // final result event). The main form's control does not show the
+            // phase labels, so read the stream and keep only the result event.
+            .then(function (response) {
+              if (response.body === null || typeof response.body.getReader !== 'function') {
+                return response.json().then(function (body) {
+                  return { ok: response.ok, result: body };
+                });
+              }
+              var reader = response.body.getReader();
+              var decoder = new TextDecoder();
+              var buffer = '';
+              var resultEvent = null;
+              function pump() {
+                return reader.read().then(function (chunk) {
+                  if (chunk.done) {
+                    return { ok: response.ok, result: resultEvent };
+                  }
+                  buffer += decoder.decode(chunk.value, { stream: true });
+                  var lines = buffer.split('\n');
+                  buffer = lines.pop();
+                  for (var i = 0; i < lines.length; i++) {
+                    if (lines[i] === '') {
+                      continue;
+                    }
+                    var event;
+                    try {
+                      event = JSON.parse(lines[i]);
+                    } catch {
+                      continue;
+                    }
+                    if (event.result !== undefined) {
+                      resultEvent = event.result;
+                    }
+                  }
+                  return pump();
+                });
+              }
+              return pump();
+            })
+            .then(({ ok, result: body }) => {
+              if (ok && body !== null) {
                 if (body.healthy) {
                   lifecycleNoteState[1](
                     t.runningOn + ' ' + (body.plan && body.plan.port ? body.plan.port : ''),
@@ -2713,7 +2961,9 @@ window.__ModuleLoader__.load({
                   lifecycleNoteState[1](t.notHealthy + (body.detail ? ': ' + body.detail : ''));
                 }
               } else {
-                lifecycleNoteState[1](t.launchFailed + (body.error ? ': ' + body.error : ''));
+                lifecycleNoteState[1](
+                  t.launchFailed + (body && body.detail ? ': ' + body.detail : ''),
+                );
               }
             })
             .catch((error) => {
@@ -2723,8 +2973,13 @@ window.__ModuleLoader__.load({
             })
             .then(() => {
               launchingState[1](false);
+              // The route persisted the run's launch command line and engine
+              // output as the last logs; the summary re-read hands the Logs
+              // section the new run, the same rule the per-entry launch and
+              // the Get apply when their run ends.
+              fetchSummary(draft.engine, draft.config);
             });
-        }, [draft, launching, editingProviderId, t]);
+        }, [draft, launching, editingProviderId, autoRebuild, t, fetchSummary]);
 
         var onStop = react.useCallback(() => {
           if (draft === null || stopping) {
@@ -2759,39 +3014,66 @@ window.__ModuleLoader__.load({
         }, [draft, stopping, editingProviderId, t]);
 
         // The per-entry launch: a card entry's own Launch control drives its
-        // own engine, not the form's draft. It records a start time and the
-        // 'launching' state (the spinner), then reads the launch result's
-        // healthy flag: a 200 before the route's health-poll timeout reads as
-        // 'running' (the control becomes Stop), a timeout reads as 'failed'
-        // (the control becomes a red Logs that opens the entry for editing).
+        // own engine, not the form's draft. It starts the launch state machine
+        // at the prereqs phase, then reads the launch stream (an NDJSON step
+        // event as each phase begins, then a final result event) and drives the
+        // machine: each step event advances the phase label (Prereqs,
+        // Downloading, Building, Launching), a healthy result settles to
+        // running (the control becomes Stop), and a failed result or the
+        // health-poll deadline settles to failed (the control becomes a red
+        // Logs that opens the entry for editing).
         var onLaunchEntry = react.useCallback(
           (provider) => {
-            var state = entryLaunch[provider.id];
-            if (state !== undefined && state.status === 'launching') {
+            var prior = entryLaunch[provider.id];
+            var status = prior !== undefined ? prior.status : 'idle';
+            // A launch in flight (a rebuild phase) is ignored; a running engine
+            // is stopped by its own Stop control, not re-launched.
+            if (status !== 'idle' && status !== 'failed') {
               return;
             }
+            var startStatus = launchNextState(status, { type: 'start' });
             entryLaunchState[1]((current) =>
               Object.assign({}, current, {
-                [provider.id]: { status: 'launching', startTime: Date.now() },
+                [provider.id]: { status: startStatus, startTime: Date.now() },
               }),
             );
-            // The route's health-poll can run up to two minutes, and a build
-            // step before it can run longer still, so a slow or hung route
-            // would leave the control on the spinner forever. A client-side
-            // deadline just past the route's cap forces the control to the red
-            // Logs state so the entry can be opened and fixed.
+            // Move the entry's launch state through the machine, reading the
+            // current status from the latest map so a late event prices the
+            // state it lands on, not a stale one.
+            var move = function (event) {
+              entryLaunchState[1]((current) => {
+                var entry = current[provider.id];
+                var next = launchNextState(entry !== undefined ? entry.status : 'idle', event);
+                return Object.assign({}, current, {
+                  [provider.id]: { status: next, startTime: Date.now() },
+                });
+              });
+            };
+            // The health-poll deadline: the route's poll runs up to two minutes,
+            // so a client-side deadline just past that cap forces a hung launch
+            // to the red Logs state. It arms only for the launch phase; the
+            // rebuild phases (prereqs, download, build) run as long as they
+            // need to, so a slow build never reads as a failure.
             var settled = false;
-            var deadline = setTimeout(function () {
-              if (settled) {
+            var deadline = null;
+            var armDeadline = function () {
+              if (deadline !== null) {
                 return;
               }
-              settled = true;
-              entryLaunchState[1]((current) =>
-                Object.assign({}, current, {
-                  [provider.id]: { status: 'failed', startTime: Date.now() },
-                }),
-              );
-            }, 150000);
+              deadline = setTimeout(function () {
+                if (settled) {
+                  return;
+                }
+                settled = true;
+                move({ type: 'failed' });
+              }, LAUNCH_HEALTH_DEADLINE_MS);
+            };
+            var clearDeadline = function () {
+              if (deadline !== null) {
+                clearTimeout(deadline);
+                deadline = null;
+              }
+            };
             fetch('/local-infer/launch', {
               method: 'POST',
               headers: { 'content-type': 'application/json' },
@@ -2804,34 +3086,86 @@ window.__ModuleLoader__.load({
                 providerId: provider.id,
               }),
             })
-              .then((response) => response.json().then((body) => ({ ok: response.ok, body: body })))
-              .then(({ ok, body }) => {
-                settled = true;
-                clearTimeout(deadline);
-                var nextStatus = ok && body.healthy ? 'running' : 'failed';
-                entryLaunchState[1]((current) =>
-                  Object.assign({}, current, {
-                    [provider.id]: { status: nextStatus, startTime: Date.now() },
-                  }),
-                );
-                // The provider status dots price the process probe on a
-                // summary fetch, so a launch that turned an engine healthy
-                // re-fetches the summary to repaint the dot from red to green.
-                fetchSummary(provider.engine, provider.config || {});
+              .then(function (response) {
+                // The launch streams NDJSON: a step event as each phase begins,
+                // then a final result event. Read the stream and drive the
+                // state machine; a response with no body (a host without
+                // streaming) settles straight to failed.
+                if (response.body === null || typeof response.body.getReader !== 'function') {
+                  settled = true;
+                  clearDeadline();
+                  move({ type: 'failed' });
+                  return Promise.resolve();
+                }
+                var reader = response.body.getReader();
+                var decoder = new TextDecoder();
+                var buffer = '';
+                function pump() {
+                  return reader.read().then(function (result) {
+                    if (result.done) {
+                      // The stream ended without a result event (a host that
+                      // cannot stream, a route that broke mid-stream): settle
+                      // to failed so the control does not sit on a phase label.
+                      if (!settled) {
+                        settled = true;
+                        clearDeadline();
+                        move({ type: 'failed' });
+                      }
+                      return;
+                    }
+                    buffer += decoder.decode(result.value, { stream: true });
+                    var lines = buffer.split('\n');
+                    buffer = lines.pop();
+                    for (var i = 0; i < lines.length; i++) {
+                      var line = lines[i];
+                      if (line === '') {
+                        continue;
+                      }
+                      var event;
+                      try {
+                        event = JSON.parse(line);
+                      } catch {
+                        // A malformed line is not a launch event; skip it.
+                        continue;
+                      }
+                      if (event.step !== undefined) {
+                        move({ type: 'step', step: event.step });
+                        // Arm the deadline only for the launch (health-poll)
+                        // step; the rebuild steps run without a timeout.
+                        if (event.step === 'launch') {
+                          armDeadline();
+                        }
+                      } else if (event.result !== undefined) {
+                        settled = true;
+                        clearDeadline();
+                        var healthy = event.result.healthy === true;
+                        move(healthy ? { type: 'healthy' } : { type: 'failed' });
+                        // The provider status dots price the process probe on a
+                        // summary fetch, so a launch that turned an engine
+                        // healthy re-fetches the summary to repaint the dot
+                        // from red to green.
+                        fetchSummary(provider.engine, provider.config || {});
+                        return;
+                      }
+                    }
+                    return pump();
+                  });
+                }
+                return pump();
               })
-              .catch(() => {
+              .catch(function () {
                 settled = true;
-                clearTimeout(deadline);
-                entryLaunchState[1]((current) =>
-                  Object.assign({}, current, {
-                    [provider.id]: { status: 'failed', startTime: Date.now() },
-                  }),
-                );
+                clearDeadline();
+                move({ type: 'failed' });
               });
           },
           [entryLaunch, fetchSummary],
         );
 
+        // The per-entry stop: a running engine's Stop control settles the
+        // launch state machine back to idle (the control reads as Launch
+        // again). The stop clears the launch record on this entry, so a
+        // recycled pid cannot re-link it.
         var onStopEntry = react.useCallback(
           (provider) => {
             fetch('/local-infer/stop', {
@@ -2848,9 +3182,16 @@ window.__ModuleLoader__.load({
             })
               .then(() => {
                 entryLaunchState[1]((current) => {
-                  var next = Object.assign({}, current);
-                  delete next[provider.id];
-                  return next;
+                  var entry = current[provider.id];
+                  var status = entry !== undefined ? entry.status : 'idle';
+                  var next = launchNextState(status, { type: 'stop' });
+                  var map = Object.assign({}, current);
+                  if (next === 'idle') {
+                    delete map[provider.id];
+                  } else {
+                    map[provider.id] = { status: next, startTime: Date.now() };
+                  }
+                  return map;
                 });
               })
               .catch(() => {
@@ -2861,17 +3202,24 @@ window.__ModuleLoader__.load({
         );
 
         // The per-entry Logs control: opening the logs loads the entry for
-        // editing AND clears the failed launch state, so the per-entry control
-        // reads as Launch again. The user fixes the config in the form and
-        // re-launches from the same entry, instead of being stuck on a
+        // editing AND resets the launch state machine to idle, so the per-entry
+        // control reads as Launch again. The user fixes the config in the form
+        // and re-launches from the same entry, instead of being stuck on a
         // non-actionable Logs control.
         var onLogsEntry = react.useCallback(
           (provider) => {
             onEditProvider(provider);
             entryLaunchState[1]((current) => {
-              var next = Object.assign({}, current);
-              delete next[provider.id];
-              return next;
+              var entry = current[provider.id];
+              var status = entry !== undefined ? entry.status : 'idle';
+              var next = launchNextState(status, { type: 'reset' });
+              var map = Object.assign({}, current);
+              if (next === 'idle') {
+                delete map[provider.id];
+              } else {
+                map[provider.id] = { status: next, startTime: Date.now() };
+              }
+              return map;
             });
           },
           [onEditProvider],
@@ -2956,9 +3304,14 @@ window.__ModuleLoader__.load({
                   : null,
               )
             : null,
-          // The card header: the section title plus the circular "?" button
-          // that shows or hides the per-field descriptions. The preference
-          // persists through the save route, so it survives a reload.
+          // The card header: the section title plus the circular refresh and
+          // "?" buttons. The refresh button re-fetches the summary and deps
+          // from the host, so the card re-prices after the harness pauses
+          // the plugin's routes and re-activates them. The refresh glyph is
+          // the primitives seed's IconRefreshOutlineRegular; a host without
+          // the seed keeps the native arrow character. The "?" button shows
+          // or hides the per-field descriptions; the preference persists
+          // through the save route, so it survives a reload.
           react.createElement(
             'div',
             {
@@ -2971,16 +3324,39 @@ window.__ModuleLoader__.load({
             },
             react.createElement('div', { style: { fontWeight: 600, fontSize: 14 } }, t.section),
             react.createElement(
-              'button',
+              'div',
               {
-                type: 'button',
-                style: HELP_BUTTON_STYLE(help),
-                title: t.helpToggle,
-                'aria-label': t.helpToggle,
-                'aria-pressed': help,
-                onClick: () => onToggleHelp(!help),
+                style: {
+                  display: 'flex',
+                  alignItems: 'center',
+                  gap: 8,
+                },
               },
-              '?',
+              react.createElement(
+                'button',
+                {
+                  type: 'button',
+                  style: HELP_BUTTON_STYLE(false),
+                  title: t.refresh,
+                  'aria-label': t.refresh,
+                  onClick: () => load(),
+                },
+                primitives && typeof primitives.IconRefreshOutlineRegular === 'function'
+                  ? react.createElement(primitives.IconRefreshOutlineRegular, { size: 12 })
+                  : '↻',
+              ),
+              react.createElement(
+                'button',
+                {
+                  type: 'button',
+                  style: HELP_BUTTON_STYLE(help),
+                  title: t.helpToggle,
+                  'aria-label': t.helpToggle,
+                  'aria-pressed': help,
+                  onClick: () => onToggleHelp(!help),
+                },
+                '?',
+              ),
             ),
           ),
           // The provider list: the saved provider entries, each a collapsed
@@ -3011,7 +3387,10 @@ window.__ModuleLoader__.load({
                 launchLabel: t.entryLaunch,
                 stopLabel: t.entryStop,
                 logsLabel: t.entryLogs,
-                launchingLabel: t.launching,
+                launchingLabel: t.entryLaunching,
+                prereqsLabel: t.entryPrereqs,
+                downloadingLabel: t.entryDownloading,
+                buildingLabel: t.entryBuilding,
               })
             : null,
           // The provider form: the Engine/Model config the card prices. It is
@@ -3314,6 +3693,94 @@ window.__ModuleLoader__.load({
                 ),
               ),
               help ? renderHelpRow(react, t.engineForkHelp) : null,
+              (() => {
+                // The build-method-dependent platform fields: local build mode
+                // shows the Build commands override, docker build mode shows the
+                // Docker tag override. Only one is visible at a time, keyed off
+                // the same buildMode the Build row prices. The placeholder seeds
+                // the engine's own default (the build step the deploy runs, or the
+                // image tag the docker deploy pulls), so an empty field reads as
+                // "use the default."
+                var engineEntry = (data.engines || []).find(
+                  (entry) => entry.id === draft.engine,
+                );
+                var buildModes = [];
+                if (engineEntry && engineEntry.supports.local) buildModes.push('local');
+                if (engineEntry && engineEntry.supports.docker) buildModes.push('docker');
+                var buildMode =
+                  typeof draft.config.buildMode === 'string'
+                    ? draft.config.buildMode
+                    : buildModes[0] || 'local';
+                if (buildMode === 'local') {
+                  return react.createElement(
+                    'div',
+                    null,
+                    react.createElement(
+                      'div',
+                      { style: ROW_STYLE },
+                      react.createElement('label', { style: LABEL_STYLE }, t.buildCommands),
+                      react.createElement(
+                        'input',
+                        Object.assign(
+                          { style: INPUT_STYLE },
+                          {
+                            type: 'text',
+                            value:
+                              typeof enginePlatform.buildCommands === 'string'
+                                ? enginePlatform.buildCommands
+                                : '',
+                            placeholder:
+                              engineEntry && engineEntry.defaultBuildCommand
+                                ? engineEntry.defaultBuildCommand
+                                : '',
+                            onChange: (event) =>
+                              onPlatform(
+                                'buildCommands',
+                                event.target.value === '' ? undefined : event.target.value,
+                              ),
+                          },
+                        ),
+                      ),
+                    ),
+                    help ? renderHelpRow(react, t.buildCommandsHelp) : null,
+                  );
+                }
+                if (buildMode === 'docker') {
+                  return react.createElement(
+                    'div',
+                    null,
+                    react.createElement(
+                      'div',
+                      { style: ROW_STYLE },
+                      react.createElement('label', { style: LABEL_STYLE }, t.dockerTag),
+                      react.createElement(
+                        'input',
+                        Object.assign(
+                          { style: INPUT_STYLE },
+                          {
+                            type: 'text',
+                            value:
+                              typeof enginePlatform.dockerTag === 'string'
+                                ? enginePlatform.dockerTag
+                                : '',
+                            placeholder:
+                              engineEntry && engineEntry.defaultDockerTag
+                                ? engineEntry.defaultDockerTag
+                                : '',
+                            onChange: (event) =>
+                              onPlatform(
+                                'dockerTag',
+                                event.target.value === '' ? undefined : event.target.value,
+                              ),
+                          },
+                        ),
+                      ),
+                    ),
+                    help ? renderHelpRow(react, t.dockerTagHelp) : null,
+                  );
+                }
+                return null;
+              })(),
             );
           })(),
           hasFields
@@ -3322,17 +3789,28 @@ window.__ModuleLoader__.load({
                   'div',
                   { key: section.group },
                   react.createElement('div', { style: SECTION_STYLE }, section.group),
-                  section.fields.map((field) =>
-                    renderField(
+                  section.fields.map((field) => {
+                    // The field value binds to the local draft, not the server
+                    // render model, so a typed keystroke shows in the input
+                    // immediately. The server model (field.value) resolves the
+                    // spec default and only surfaces after the debounced
+                    // re-price settles. A key the user has not edited is
+                    // absent from the draft, so it falls back to the model.
+                    var draftValue = draft.config[field.key];
+                    var effectiveField =
+                      draftValue !== undefined
+                        ? Object.assign({}, field, { value: draftValue })
+                        : field;
+                    return renderField(
                       react,
-                      field,
+                      effectiveField,
                       onValue,
                       inlineWarnings[field.key],
                       primitives,
                       help,
                       t,
-                    ),
-                  ),
+                    );
+                  }),
                 ),
               )
             : react.createElement('div', { style: { fontSize: 12, opacity: 0.7 } }, t.noParameters),
@@ -3408,6 +3886,7 @@ window.__ModuleLoader__.load({
               onAllowRun: onAllowRun,
               onRun: onRun,
               onGet: onGet,
+              getting: getting,
               installing: installing,
               copyNote: copyNote,
               depsNote: depsNote,
@@ -3418,6 +3897,8 @@ window.__ModuleLoader__.load({
           // read-only text area (a launch fills it; the card never edits it),
           // and the log-file location the launch writes to. The location field
           // edits the template the route resolves and writes on the next run.
+          // While a Get is in flight the streamed buffer wins: the git sync,
+          // dependency, and build output appends there as it lands.
           react.createElement(
             'div',
             { style: { marginTop: 8 } },
@@ -3435,7 +3916,7 @@ window.__ModuleLoader__.load({
                 color: 'inherit',
                 background: 'transparent',
               },
-              value: data.lastLogs || '',
+              value: getLogs !== null ? getLogs : data.lastLogs || '',
               readOnly: true,
               'aria-label': t.logs,
             }),
@@ -3455,8 +3936,12 @@ window.__ModuleLoader__.load({
           // draft's engine is down, Stop while a healthy launch set draftRunning,
           // and an in-flight spinner (disabled) while a launch or stop is in
           // flight. Launch stays disabled while the deps panel reports a
-          // missing host dependency, the same gate the panel's "Get" button
-          // reads. The note reports the answer the route returned.
+          // missing host dependency or a Get run is in flight, and re-enables
+          // when the build finishes, errors, or falls silent for GET_IDLE_MS.
+          // The Auto Rebuild checkbox sits after the control: checked, a
+          // launch runs the git sync (fetch, rebase, rebuild) first;
+          // unchecked, the launch starts the checkout as-is. The note reports
+          // the answer the route returned.
           react.createElement(
             'div',
             { style: { display: 'flex', alignItems: 'center', gap: 8, marginTop: 8 } },
@@ -3491,10 +3976,19 @@ window.__ModuleLoader__.load({
                       'primary',
                       {
                         onClick: onLaunch,
-                        disabled: deps !== null && deps.allSatisfied !== true,
+                        disabled:
+                          getting || (deps !== null && deps.allSatisfied !== true),
                       },
                       t.launch,
                     ),
+            // The Auto Rebuild checkbox: checked, a launch runs the git sync
+            // (fetch, rebase, rebuild) before the spawn; unchecked, the
+            // launch starts the checkout as-is.
+            renderCheckbox(react, primitives, {
+              checked: autoRebuild,
+              onChange: (next) => autoRebuildState[1](next),
+              label: t.autoRebuild,
+            }),
           ),
           lifecycleNote
             ? react.createElement('div', { style: { fontSize: 12 } }, lifecycleNote)